﻿using System;
using System.ComponentModel;
using System.IO;
using System.Runtime.Serialization;

namespace HalconDotNet
{
	/// <summary>Represents an instance of a 3D object model.</summary>
	// Token: 0x02000050 RID: 80
	[Serializable]
	public class HObjectModel3D : HHandle, ISerializable, ICloneable
	{
		// Token: 0x06000B1A RID: 2842 RVA: 0x0004611A File Offset: 0x0004431A
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HObjectModel3D(IntPtr handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x06000B1B RID: 2843 RVA: 0x00046129 File Offset: 0x00044329
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HObjectModel3D(HHandle handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x06000B1C RID: 2844 RVA: 0x00046138 File Offset: 0x00044338
		private void AssertSemType()
		{
			base.AssertSemType("object_model_3d");
		}

		// Token: 0x06000B1D RID: 2845 RVA: 0x00046145 File Offset: 0x00044345
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HObjectModel3D obj)
		{
			obj = new HObjectModel3D(HHandleBase.UNDEF);
			return obj.Load(proc, parIndex, err);
		}

		// Token: 0x06000B1E RID: 2846 RVA: 0x00046160 File Offset: 0x00044360
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HObjectModel3D[] obj)
		{
			HTuple htuple;
			err = HTuple.LoadNew(proc, parIndex, err, out htuple);
			obj = new HObjectModel3D[htuple.Length];
			for (int i = 0; i < htuple.Length; i++)
			{
				obj[i] = new HObjectModel3D(HalconAPI.IsLegacyHandleMode() ? htuple[i].IP : htuple[i].H);
			}
			htuple.Dispose();
			return err;
		}

		/// <summary>
		///   Create an empty 3D object model.
		///   Modified instance represents: Handle of the new 3D object model.
		/// </summary>
		// Token: 0x06000B1F RID: 2847 RVA: 0x000461D0 File Offset: 0x000443D0
		public HObjectModel3D()
		{
			IntPtr proc = HalconAPI.PreCall(1065);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a 3D object model that represents a point cloud from a set of 3D points.
		///   Modified instance represents: Handle of the resulting 3D object model.
		/// </summary>
		/// <param name="x">The x-coordinates of the points in the 3D point cloud.</param>
		/// <param name="y">The y-coordinates of the points in the 3D point cloud.</param>
		/// <param name="z">The z-coordinates of the points in the 3D point cloud.</param>
		// Token: 0x06000B20 RID: 2848 RVA: 0x00046214 File Offset: 0x00044414
		public HObjectModel3D(HTuple x, HTuple y, HTuple z)
		{
			IntPtr proc = HalconAPI.PreCall(1069);
			HalconAPI.Store(proc, 0, x);
			HalconAPI.Store(proc, 1, y);
			HalconAPI.Store(proc, 2, z);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(x);
			HalconAPI.UnpinTuple(y);
			HalconAPI.UnpinTuple(z);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a 3D object model that represents a point cloud from a set of 3D points.
		///   Modified instance represents: Handle of the resulting 3D object model.
		/// </summary>
		/// <param name="x">The x-coordinates of the points in the 3D point cloud.</param>
		/// <param name="y">The y-coordinates of the points in the 3D point cloud.</param>
		/// <param name="z">The z-coordinates of the points in the 3D point cloud.</param>
		// Token: 0x06000B21 RID: 2849 RVA: 0x00046284 File Offset: 0x00044484
		public HObjectModel3D(double x, double y, double z)
		{
			IntPtr proc = HalconAPI.PreCall(1069);
			HalconAPI.StoreD(proc, 0, x);
			HalconAPI.StoreD(proc, 1, y);
			HalconAPI.StoreD(proc, 2, z);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Transform 3D points from images to a 3D object model.
		///   Modified instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="x">Image with the X-Coordinates and the ROI of the 3D points.</param>
		/// <param name="y">Image with the Y-Coordinates of the 3D points.</param>
		/// <param name="z">Image with the Z-Coordinates of the 3D points.</param>
		// Token: 0x06000B22 RID: 2850 RVA: 0x000462E0 File Offset: 0x000444E0
		public HObjectModel3D(HImage x, HImage y, HImage z)
		{
			IntPtr proc = HalconAPI.PreCall(1093);
			HalconAPI.Store(proc, 1, x);
			HalconAPI.Store(proc, 2, y);
			HalconAPI.Store(proc, 3, z);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(x);
			GC.KeepAlive(y);
			GC.KeepAlive(z);
		}

		/// <summary>
		///   Read a 3D object model from a file.
		///   Modified instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="fileName">Filename of the file to be read. Default: "mvtec_bunny_normals"</param>
		/// <param name="scale">Scale of the data in the file. Default: "m"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <param name="status">Status information.</param>
		// Token: 0x06000B23 RID: 2851 RVA: 0x00046350 File Offset: 0x00044550
		public HObjectModel3D(string fileName, HTuple scale, HTuple genParamName, HTuple genParamValue, out HTuple status)
		{
			IntPtr proc = HalconAPI.PreCall(1104);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.Store(proc, 1, scale);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(scale);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			num = HTuple.LoadNew(proc, 1, num, out status);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Read a 3D object model from a file.
		///   Modified instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="fileName">Filename of the file to be read. Default: "mvtec_bunny_normals"</param>
		/// <param name="scale">Scale of the data in the file. Default: "m"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <param name="status">Status information.</param>
		// Token: 0x06000B24 RID: 2852 RVA: 0x000463DC File Offset: 0x000445DC
		public HObjectModel3D(string fileName, string scale, string genParamName, string genParamValue, out string status)
		{
			IntPtr proc = HalconAPI.PreCall(1104);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.StoreS(proc, 1, scale);
			HalconAPI.StoreS(proc, 2, genParamName);
			HalconAPI.StoreS(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			num = HalconAPI.LoadS(proc, 1, num, out status);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		// Token: 0x06000B25 RID: 2853 RVA: 0x00046454 File Offset: 0x00044654
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = this.SerializeObjectModel3d();
			byte[] value = hserializedItem;
			hserializedItem.Dispose();
			info.AddValue("data", value, typeof(byte[]));
		}

		// Token: 0x06000B26 RID: 2854 RVA: 0x0004648C File Offset: 0x0004468C
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HObjectModel3D(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = new HSerializedItem((byte[])info.GetValue("data", typeof(byte[])));
			this.DeserializeObjectModel3d(hserializedItem);
			hserializedItem.Dispose();
		}

		/// <summary>Serialize object to binary stream in HALCON format</summary>
		// Token: 0x06000B27 RID: 2855 RVA: 0x000464CC File Offset: 0x000446CC
		public new void Serialize(Stream stream)
		{
			HSerializedItem hserializedItem = this.SerializeObjectModel3d();
			hserializedItem.Serialize(stream);
			hserializedItem.Dispose();
		}

		/// <summary>Deserialize object from binary stream in HALCON format</summary>
		// Token: 0x06000B28 RID: 2856 RVA: 0x000464E0 File Offset: 0x000446E0
		public new static HObjectModel3D Deserialize(Stream stream)
		{
			HObjectModel3D hobjectModel3D = new HObjectModel3D();
			HSerializedItem hserializedItem = HSerializedItem.Deserialize(stream);
			hobjectModel3D.DeserializeObjectModel3d(hserializedItem);
			hserializedItem.Dispose();
			return hobjectModel3D;
		}

		// Token: 0x06000B29 RID: 2857 RVA: 0x00046506 File Offset: 0x00044706
		object ICloneable.Clone()
		{
			return this.Clone();
		}

		// Token: 0x06000B2A RID: 2858 RVA: 0x00046510 File Offset: 0x00044710
		public new HObjectModel3D Clone()
		{
			HSerializedItem hserializedItem = this.SerializeObjectModel3d();
			HObjectModel3D hobjectModel3D = new HObjectModel3D();
			hobjectModel3D.DeserializeObjectModel3d(hserializedItem);
			hserializedItem.Dispose();
			return hobjectModel3D;
		}

		/// <summary>
		///   Get the result of a calibrated measurement performed with the  sheet-of-light technique as a 3D object model.
		///   Modified instance represents: Handle of the resulting 3D object model.
		/// </summary>
		/// <param name="sheetOfLightModelID">Handle for accessing the sheet-of-light model.</param>
		// Token: 0x06000B2B RID: 2859 RVA: 0x00046538 File Offset: 0x00044738
		public void GetSheetOfLightResultObjectModel3d(HSheetOfLightModel sheetOfLightModelID)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(380);
			HalconAPI.Store(proc, 0, sheetOfLightModelID);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(sheetOfLightModelID);
		}

		/// <summary>Fit 3D primitives into a set of 3D points.</summary>
		/// <param name="objectModel3D">Handle of the input 3D object model.</param>
		/// <param name="genParamName">Names of the generic parameters.</param>
		/// <param name="genParamValue">Values of the generic parameters.</param>
		/// <returns>Handle of the output 3D object model.</returns>
		// Token: 0x06000B2C RID: 2860 RVA: 0x0004658C File Offset: 0x0004478C
		public static HObjectModel3D[] FitPrimitivesObjectModel3d(HObjectModel3D[] objectModel3D, HTuple genParamName, HTuple genParamValue)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(411);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Fit 3D primitives into a set of 3D points.
		///   Instance represents: Handle of the input 3D object model.
		/// </summary>
		/// <param name="genParamName">Names of the generic parameters.</param>
		/// <param name="genParamValue">Values of the generic parameters.</param>
		/// <returns>Handle of the output 3D object model.</returns>
		// Token: 0x06000B2D RID: 2861 RVA: 0x00046600 File Offset: 0x00044800
		public HObjectModel3D FitPrimitivesObjectModel3d(HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(411);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Segment a set of 3D points into sub-sets with similar characteristics.</summary>
		/// <param name="objectModel3D">Handle of the input 3D object model.</param>
		/// <param name="genParamName">Names of the generic parameters.</param>
		/// <param name="genParamValue">Values of the generic parameters.</param>
		/// <returns>Handle of the output 3D object model.</returns>
		// Token: 0x06000B2E RID: 2862 RVA: 0x00046664 File Offset: 0x00044864
		public static HObjectModel3D[] SegmentObjectModel3d(HObjectModel3D[] objectModel3D, HTuple genParamName, HTuple genParamValue)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(412);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Segment a set of 3D points into sub-sets with similar characteristics.
		///   Instance represents: Handle of the input 3D object model.
		/// </summary>
		/// <param name="genParamName">Names of the generic parameters.</param>
		/// <param name="genParamValue">Values of the generic parameters.</param>
		/// <returns>Handle of the output 3D object model.</returns>
		// Token: 0x06000B2F RID: 2863 RVA: 0x000466D8 File Offset: 0x000448D8
		public HObjectModel3D SegmentObjectModel3d(HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(412);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Calculate the 3D surface normals of a 3D object model.</summary>
		/// <param name="objectModel3D">Handle of the 3D object model containing 3D point data.</param>
		/// <param name="method">Normals calculation method. Default: "mls"</param>
		/// <param name="genParamName">Names of generic smoothing parameters. Default: []</param>
		/// <param name="genParamValue">Values of generic smoothing parameters. Default: []</param>
		/// <returns>Handle of the 3D object model with calculated 3D normals.</returns>
		// Token: 0x06000B30 RID: 2864 RVA: 0x0004673C File Offset: 0x0004493C
		public static HObjectModel3D[] SurfaceNormalsObjectModel3d(HObjectModel3D[] objectModel3D, string method, HTuple genParamName, HTuple genParamValue)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(515);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.StoreS(proc, 1, method);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Calculate the 3D surface normals of a 3D object model.
		///   Instance represents: Handle of the 3D object model containing 3D point data.
		/// </summary>
		/// <param name="method">Normals calculation method. Default: "mls"</param>
		/// <param name="genParamName">Names of generic smoothing parameters. Default: []</param>
		/// <param name="genParamValue">Values of generic smoothing parameters. Default: []</param>
		/// <returns>Handle of the 3D object model with calculated 3D normals.</returns>
		// Token: 0x06000B31 RID: 2865 RVA: 0x000467B8 File Offset: 0x000449B8
		public HObjectModel3D SurfaceNormalsObjectModel3d(string method, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(515);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, method);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Smooth the 3D points of a 3D object model.</summary>
		/// <param name="objectModel3D">Handle of the 3D object model containing 3D point data.</param>
		/// <param name="method">Smoothing method. Default: "mls"</param>
		/// <param name="genParamName">Names of generic smoothing parameters. Default: []</param>
		/// <param name="genParamValue">Values of generic smoothing parameters. Default: []</param>
		/// <returns>Handle of the 3D object model with the smoothed 3D point data.</returns>
		// Token: 0x06000B32 RID: 2866 RVA: 0x00046824 File Offset: 0x00044A24
		public static HObjectModel3D[] SmoothObjectModel3d(HObjectModel3D[] objectModel3D, string method, HTuple genParamName, HTuple genParamValue)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(516);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.StoreS(proc, 1, method);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Smooth the 3D points of a 3D object model.
		///   Instance represents: Handle of the 3D object model containing 3D point data.
		/// </summary>
		/// <param name="method">Smoothing method. Default: "mls"</param>
		/// <param name="genParamName">Names of generic smoothing parameters. Default: []</param>
		/// <param name="genParamValue">Values of generic smoothing parameters. Default: []</param>
		/// <returns>Handle of the 3D object model with the smoothed 3D point data.</returns>
		// Token: 0x06000B33 RID: 2867 RVA: 0x000468A0 File Offset: 0x00044AA0
		public HObjectModel3D SmoothObjectModel3d(string method, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(516);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, method);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Create a surface triangulation for a 3D object model.</summary>
		/// <param name="objectModel3D">Handle of the 3D object model containing 3D point data.</param>
		/// <param name="method">Triangulation method. Default: "greedy"</param>
		/// <param name="genParamName">Names of the generic triangulation parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic triangulation parameters. Default: []</param>
		/// <param name="information">Additional information about the triangulation process.</param>
		/// <returns>Handle of the 3D object model with the triangulated surface.</returns>
		// Token: 0x06000B34 RID: 2868 RVA: 0x0004690C File Offset: 0x00044B0C
		public static HObjectModel3D[] TriangulateObjectModel3d(HObjectModel3D[] objectModel3D, string method, HTuple genParamName, HTuple genParamValue, out HTuple information)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(517);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.StoreS(proc, 1, method);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, num, out information);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Create a surface triangulation for a 3D object model.
		///   Instance represents: Handle of the 3D object model containing 3D point data.
		/// </summary>
		/// <param name="method">Triangulation method. Default: "greedy"</param>
		/// <param name="genParamName">Names of the generic triangulation parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic triangulation parameters. Default: []</param>
		/// <param name="information">Additional information about the triangulation process.</param>
		/// <returns>Handle of the 3D object model with the triangulated surface.</returns>
		// Token: 0x06000B35 RID: 2869 RVA: 0x00046998 File Offset: 0x00044B98
		public HObjectModel3D TriangulateObjectModel3d(string method, HTuple genParamName, HTuple genParamValue, out int information)
		{
			IntPtr proc = HalconAPI.PreCall(517);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, method);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadI(proc, 1, num, out information);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Reconstruct surface from calibrated multi-view stereo images.
		///   Modified instance represents: Handle to the resulting surface.
		/// </summary>
		/// <param name="images">An image array acquired by the camera setup associated with the stereo model.</param>
		/// <param name="stereoModelID">Handle of the stereo model.</param>
		// Token: 0x06000B36 RID: 2870 RVA: 0x00046A18 File Offset: 0x00044C18
		public void ReconstructSurfaceStereo(HImage images, HStereoModel stereoModelID)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(521);
			HalconAPI.Store(proc, 1, images);
			HalconAPI.Store(proc, 0, stereoModelID);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(images);
			GC.KeepAlive(stereoModelID);
		}

		/// <summary>
		///   Refine the position and deformation of a deformable surface model in a 3D scene.
		///   Instance represents: Handle of the 3D object model containing the scene.
		/// </summary>
		/// <param name="deformableSurfaceModel">Handle of the deformable surface model.</param>
		/// <param name="relSamplingDistance">Relative sampling distance of the scene. Default: 0.05</param>
		/// <param name="initialDeformationObjectModel3D">Initial deformation of the 3D object model</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <param name="deformableSurfaceMatchingResult">Handle of the matching result.</param>
		/// <returns>Score of the refined model.</returns>
		// Token: 0x06000B37 RID: 2871 RVA: 0x00046A78 File Offset: 0x00044C78
		public HTuple RefineDeformableSurfaceModel(HDeformableSurfaceModel deformableSurfaceModel, double relSamplingDistance, HObjectModel3D initialDeformationObjectModel3D, HTuple genParamName, HTuple genParamValue, out HDeformableSurfaceMatchingResult[] deformableSurfaceMatchingResult)
		{
			IntPtr proc = HalconAPI.PreCall(1026);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, deformableSurfaceModel);
			HalconAPI.StoreD(proc, 2, relSamplingDistance);
			HalconAPI.Store(proc, 3, initialDeformationObjectModel3D);
			HalconAPI.Store(proc, 4, genParamName);
			HalconAPI.Store(proc, 5, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HDeformableSurfaceMatchingResult.LoadNew(proc, 1, num, out deformableSurfaceMatchingResult);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(deformableSurfaceModel);
			GC.KeepAlive(initialDeformationObjectModel3D);
			return result;
		}

		/// <summary>
		///   Refine the position and deformation of a deformable surface model in a 3D scene.
		///   Instance represents: Handle of the 3D object model containing the scene.
		/// </summary>
		/// <param name="deformableSurfaceModel">Handle of the deformable surface model.</param>
		/// <param name="relSamplingDistance">Relative sampling distance of the scene. Default: 0.05</param>
		/// <param name="initialDeformationObjectModel3D">Initial deformation of the 3D object model</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <param name="deformableSurfaceMatchingResult">Handle of the matching result.</param>
		/// <returns>Score of the refined model.</returns>
		// Token: 0x06000B38 RID: 2872 RVA: 0x00046B18 File Offset: 0x00044D18
		public double RefineDeformableSurfaceModel(HDeformableSurfaceModel deformableSurfaceModel, double relSamplingDistance, HObjectModel3D initialDeformationObjectModel3D, string genParamName, string genParamValue, out HDeformableSurfaceMatchingResult deformableSurfaceMatchingResult)
		{
			IntPtr proc = HalconAPI.PreCall(1026);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, deformableSurfaceModel);
			HalconAPI.StoreD(proc, 2, relSamplingDistance);
			HalconAPI.Store(proc, 3, initialDeformationObjectModel3D);
			HalconAPI.StoreS(proc, 4, genParamName);
			HalconAPI.StoreS(proc, 5, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HDeformableSurfaceMatchingResult.LoadNew(proc, 1, num, out deformableSurfaceMatchingResult);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(deformableSurfaceModel);
			GC.KeepAlive(initialDeformationObjectModel3D);
			return result;
		}

		/// <summary>
		///   Find the best match of a deformable surface model in a 3D scene.
		///   Instance represents: Handle of the 3D object model containing the scene.
		/// </summary>
		/// <param name="deformableSurfaceModel">Handle of the deformable surface model.</param>
		/// <param name="relSamplingDistance">Scene sampling distance relative to the diameter of the surface model. Default: 0.05</param>
		/// <param name="minScore">Minimum score of the returned match. Default: 0</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <param name="deformableSurfaceMatchingResult">Handle of the matching result.</param>
		/// <returns>Score of the found instances of the surface model.</returns>
		// Token: 0x06000B39 RID: 2873 RVA: 0x00046BAC File Offset: 0x00044DAC
		public HTuple FindDeformableSurfaceModel(HDeformableSurfaceModel deformableSurfaceModel, double relSamplingDistance, HTuple minScore, HTuple genParamName, HTuple genParamValue, out HDeformableSurfaceMatchingResult[] deformableSurfaceMatchingResult)
		{
			IntPtr proc = HalconAPI.PreCall(1027);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, deformableSurfaceModel);
			HalconAPI.StoreD(proc, 2, relSamplingDistance);
			HalconAPI.Store(proc, 3, minScore);
			HalconAPI.Store(proc, 4, genParamName);
			HalconAPI.Store(proc, 5, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HDeformableSurfaceMatchingResult.LoadNew(proc, 1, num, out deformableSurfaceMatchingResult);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(deformableSurfaceModel);
			return result;
		}

		/// <summary>
		///   Find the best match of a deformable surface model in a 3D scene.
		///   Instance represents: Handle of the 3D object model containing the scene.
		/// </summary>
		/// <param name="deformableSurfaceModel">Handle of the deformable surface model.</param>
		/// <param name="relSamplingDistance">Scene sampling distance relative to the diameter of the surface model. Default: 0.05</param>
		/// <param name="minScore">Minimum score of the returned match. Default: 0</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <param name="deformableSurfaceMatchingResult">Handle of the matching result.</param>
		/// <returns>Score of the found instances of the surface model.</returns>
		// Token: 0x06000B3A RID: 2874 RVA: 0x00046C4C File Offset: 0x00044E4C
		public double FindDeformableSurfaceModel(HDeformableSurfaceModel deformableSurfaceModel, double relSamplingDistance, double minScore, HTuple genParamName, HTuple genParamValue, out HDeformableSurfaceMatchingResult deformableSurfaceMatchingResult)
		{
			IntPtr proc = HalconAPI.PreCall(1027);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, deformableSurfaceModel);
			HalconAPI.StoreD(proc, 2, relSamplingDistance);
			HalconAPI.StoreD(proc, 3, minScore);
			HalconAPI.Store(proc, 4, genParamName);
			HalconAPI.Store(proc, 5, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HDeformableSurfaceMatchingResult.LoadNew(proc, 1, num, out deformableSurfaceMatchingResult);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(deformableSurfaceModel);
			return result;
		}

		/// <summary>Add a sample deformation to a deformable surface model</summary>
		/// <param name="deformableSurfaceModel">Handle of the deformable surface model.</param>
		/// <param name="objectModel3D">Handle of the deformed 3D object model.</param>
		// Token: 0x06000B3B RID: 2875 RVA: 0x00046CE8 File Offset: 0x00044EE8
		public static void AddDeformableSurfaceModelSample(HDeformableSurfaceModel deformableSurfaceModel, HObjectModel3D[] objectModel3D)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(1030);
			HalconAPI.Store(proc, 0, deformableSurfaceModel);
			HalconAPI.Store(proc, 1, htuple);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(deformableSurfaceModel);
			GC.KeepAlive(objectModel3D);
		}

		/// <summary>
		///   Add a sample deformation to a deformable surface model
		///   Instance represents: Handle of the deformed 3D object model.
		/// </summary>
		/// <param name="deformableSurfaceModel">Handle of the deformable surface model.</param>
		// Token: 0x06000B3C RID: 2876 RVA: 0x00046D38 File Offset: 0x00044F38
		public void AddDeformableSurfaceModelSample(HDeformableSurfaceModel deformableSurfaceModel)
		{
			IntPtr proc = HalconAPI.PreCall(1030);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, deformableSurfaceModel);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(deformableSurfaceModel);
		}

		/// <summary>
		///   Create the data structure needed to perform deformable surface-based matching.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="relSamplingDistance">Sampling distance relative to the object's diameter Default: 0.05</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Handle of the deformable surface model.</returns>
		// Token: 0x06000B3D RID: 2877 RVA: 0x00046D7C File Offset: 0x00044F7C
		public HDeformableSurfaceModel CreateDeformableSurfaceModel(double relSamplingDistance, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1031);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, relSamplingDistance);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HDeformableSurfaceModel result;
			num = HDeformableSurfaceModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Create the data structure needed to perform deformable surface-based matching.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="relSamplingDistance">Sampling distance relative to the object's diameter Default: 0.05</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Handle of the deformable surface model.</returns>
		// Token: 0x06000B3E RID: 2878 RVA: 0x00046DE8 File Offset: 0x00044FE8
		public HDeformableSurfaceModel CreateDeformableSurfaceModel(double relSamplingDistance, string genParamName, string genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1031);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, relSamplingDistance);
			HalconAPI.StoreS(proc, 2, genParamName);
			HalconAPI.StoreS(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HDeformableSurfaceModel result;
			num = HDeformableSurfaceModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Refine the pose of a surface model in a 3D scene.
		///   Instance represents: Handle of the 3D object model containing the scene.
		/// </summary>
		/// <param name="surfaceModelID">Handle of the surface model.</param>
		/// <param name="initialPose">Initial pose of the surface model in the scene.</param>
		/// <param name="minScore">Minimum score of the returned poses. Default: 0</param>
		/// <param name="returnResultHandle">Enable returning a result handle in SurfaceMatchingResultID. Default: "false"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <param name="score">Score of the found instances of the model.</param>
		/// <param name="surfaceMatchingResultID">Handle of the matching result, if enabled in ReturnResultHandle.</param>
		/// <returns>3D pose of the surface model in the scene.</returns>
		// Token: 0x06000B3F RID: 2879 RVA: 0x00046E48 File Offset: 0x00045048
		public HPose[] RefineSurfaceModelPose(HSurfaceModel surfaceModelID, HPose[] initialPose, HTuple minScore, string returnResultHandle, HTuple genParamName, HTuple genParamValue, out HTuple score, out HSurfaceMatchingResult[] surfaceMatchingResultID)
		{
			HTuple htuple = HData.ConcatArray(initialPose);
			IntPtr proc = HalconAPI.PreCall(1041);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, surfaceModelID);
			HalconAPI.Store(proc, 2, htuple);
			HalconAPI.Store(proc, 3, minScore);
			HalconAPI.StoreS(proc, 4, returnResultHandle);
			HalconAPI.Store(proc, 5, genParamName);
			HalconAPI.Store(proc, 6, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out score);
			num = HSurfaceMatchingResult.LoadNew(proc, 2, num, out surfaceMatchingResultID);
			HalconAPI.PostCall(proc, num);
			HPose[] result = HPose.SplitArray(data);
			GC.KeepAlive(this);
			GC.KeepAlive(surfaceModelID);
			return result;
		}

		/// <summary>
		///   Refine the pose of a surface model in a 3D scene.
		///   Instance represents: Handle of the 3D object model containing the scene.
		/// </summary>
		/// <param name="surfaceModelID">Handle of the surface model.</param>
		/// <param name="initialPose">Initial pose of the surface model in the scene.</param>
		/// <param name="minScore">Minimum score of the returned poses. Default: 0</param>
		/// <param name="returnResultHandle">Enable returning a result handle in SurfaceMatchingResultID. Default: "false"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <param name="score">Score of the found instances of the model.</param>
		/// <param name="surfaceMatchingResultID">Handle of the matching result, if enabled in ReturnResultHandle.</param>
		/// <returns>3D pose of the surface model in the scene.</returns>
		// Token: 0x06000B40 RID: 2880 RVA: 0x00046F1C File Offset: 0x0004511C
		public HPose RefineSurfaceModelPose(HSurfaceModel surfaceModelID, HPose initialPose, double minScore, string returnResultHandle, HTuple genParamName, HTuple genParamValue, out HTuple score, out HSurfaceMatchingResult surfaceMatchingResultID)
		{
			IntPtr proc = HalconAPI.PreCall(1041);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, surfaceModelID);
			HalconAPI.Store(proc, 2, initialPose);
			HalconAPI.StoreD(proc, 3, minScore);
			HalconAPI.StoreS(proc, 4, returnResultHandle);
			HalconAPI.Store(proc, 5, genParamName);
			HalconAPI.Store(proc, 6, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(initialPose);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out score);
			num = HSurfaceMatchingResult.LoadNew(proc, 2, num, out surfaceMatchingResultID);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(surfaceModelID);
			return result;
		}

		/// <summary>
		///   Find the best matches of a surface model in a 3D scene.
		///   Instance represents: Handle of the 3D object model containing the scene.
		/// </summary>
		/// <param name="surfaceModelID">Handle of the surface model.</param>
		/// <param name="relSamplingDistance">Scene sampling distance relative to the diameter of the surface model. Default: 0.05</param>
		/// <param name="keyPointFraction">Fraction of sampled scene points used as key points. Default: 0.2</param>
		/// <param name="minScore">Minimum score of the returned poses. Default: 0</param>
		/// <param name="returnResultHandle">Enable returning a result handle in SurfaceMatchingResultID. Default: "false"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <param name="score">Score of the found instances of the surface model.</param>
		/// <param name="surfaceMatchingResultID">Handle of the matching result, if enabled in ReturnResultHandle.</param>
		/// <returns>3D pose of the surface model in the scene.</returns>
		// Token: 0x06000B41 RID: 2881 RVA: 0x00046FE4 File Offset: 0x000451E4
		public HPose[] FindSurfaceModel(HSurfaceModel surfaceModelID, double relSamplingDistance, double keyPointFraction, HTuple minScore, string returnResultHandle, HTuple genParamName, HTuple genParamValue, out HTuple score, out HSurfaceMatchingResult[] surfaceMatchingResultID)
		{
			IntPtr proc = HalconAPI.PreCall(1042);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, surfaceModelID);
			HalconAPI.StoreD(proc, 2, relSamplingDistance);
			HalconAPI.StoreD(proc, 3, keyPointFraction);
			HalconAPI.Store(proc, 4, minScore);
			HalconAPI.StoreS(proc, 5, returnResultHandle);
			HalconAPI.Store(proc, 6, genParamName);
			HalconAPI.Store(proc, 7, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out score);
			num = HSurfaceMatchingResult.LoadNew(proc, 2, num, out surfaceMatchingResultID);
			HalconAPI.PostCall(proc, num);
			HPose[] result = HPose.SplitArray(data);
			GC.KeepAlive(this);
			GC.KeepAlive(surfaceModelID);
			return result;
		}

		/// <summary>
		///   Find the best matches of a surface model in a 3D scene.
		///   Instance represents: Handle of the 3D object model containing the scene.
		/// </summary>
		/// <param name="surfaceModelID">Handle of the surface model.</param>
		/// <param name="relSamplingDistance">Scene sampling distance relative to the diameter of the surface model. Default: 0.05</param>
		/// <param name="keyPointFraction">Fraction of sampled scene points used as key points. Default: 0.2</param>
		/// <param name="minScore">Minimum score of the returned poses. Default: 0</param>
		/// <param name="returnResultHandle">Enable returning a result handle in SurfaceMatchingResultID. Default: "false"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <param name="score">Score of the found instances of the surface model.</param>
		/// <param name="surfaceMatchingResultID">Handle of the matching result, if enabled in ReturnResultHandle.</param>
		/// <returns>3D pose of the surface model in the scene.</returns>
		// Token: 0x06000B42 RID: 2882 RVA: 0x000470B0 File Offset: 0x000452B0
		public HPose FindSurfaceModel(HSurfaceModel surfaceModelID, double relSamplingDistance, double keyPointFraction, double minScore, string returnResultHandle, HTuple genParamName, HTuple genParamValue, out HTuple score, out HSurfaceMatchingResult surfaceMatchingResultID)
		{
			IntPtr proc = HalconAPI.PreCall(1042);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, surfaceModelID);
			HalconAPI.StoreD(proc, 2, relSamplingDistance);
			HalconAPI.StoreD(proc, 3, keyPointFraction);
			HalconAPI.StoreD(proc, 4, minScore);
			HalconAPI.StoreS(proc, 5, returnResultHandle);
			HalconAPI.Store(proc, 6, genParamName);
			HalconAPI.Store(proc, 7, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out score);
			num = HSurfaceMatchingResult.LoadNew(proc, 2, num, out surfaceMatchingResultID);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(surfaceModelID);
			return result;
		}

		/// <summary>
		///   Create the data structure needed to perform surface-based matching.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="relSamplingDistance">Sampling distance relative to the object's diameter Default: 0.03</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Handle of the surface model.</returns>
		// Token: 0x06000B43 RID: 2883 RVA: 0x00047170 File Offset: 0x00045370
		public HSurfaceModel CreateSurfaceModel(double relSamplingDistance, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1044);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, relSamplingDistance);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HSurfaceModel result;
			num = HSurfaceModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Create the data structure needed to perform surface-based matching.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="relSamplingDistance">Sampling distance relative to the object's diameter Default: 0.03</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Handle of the surface model.</returns>
		// Token: 0x06000B44 RID: 2884 RVA: 0x000471DC File Offset: 0x000453DC
		public HSurfaceModel CreateSurfaceModel(double relSamplingDistance, string genParamName, string genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1044);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, relSamplingDistance);
			HalconAPI.StoreS(proc, 2, genParamName);
			HalconAPI.StoreS(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HSurfaceModel result;
			num = HSurfaceModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Simplify a triangulated 3D object model.</summary>
		/// <param name="objectModel3D">Handle of the 3D object model that should be simplified.</param>
		/// <param name="method">Method that should be used for simplification. Default: "preserve_point_coordinates"</param>
		/// <param name="amount">Degree of simplification (default: percentage of remaining model points).</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Handle of the simplified 3D object model.</returns>
		// Token: 0x06000B45 RID: 2885 RVA: 0x0004723C File Offset: 0x0004543C
		public static HObjectModel3D[] SimplifyObjectModel3d(HObjectModel3D[] objectModel3D, string method, HTuple amount, HTuple genParamName, HTuple genParamValue)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(1060);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.StoreS(proc, 1, method);
			HalconAPI.Store(proc, 2, amount);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(amount);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Simplify a triangulated 3D object model.
		///   Instance represents: Handle of the 3D object model that should be simplified.
		/// </summary>
		/// <param name="method">Method that should be used for simplification. Default: "preserve_point_coordinates"</param>
		/// <param name="amount">Degree of simplification (default: percentage of remaining model points).</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Handle of the simplified 3D object model.</returns>
		// Token: 0x06000B46 RID: 2886 RVA: 0x000472C8 File Offset: 0x000454C8
		public HObjectModel3D SimplifyObjectModel3d(string method, double amount, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1060);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, method);
			HalconAPI.StoreD(proc, 2, amount);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the distances of the points of one 3D object model to another 3D object model.
		///   Instance represents: Handle of the source 3D object model.
		/// </summary>
		/// <param name="objectModel3DTo">Handle of the target 3D object model.</param>
		/// <param name="pose">Pose of the source 3D object model in the target 3D object model. Default: []</param>
		/// <param name="maxDistance">Maximum distance of interest. Default: 0</param>
		/// <param name="genParamName">Names of the generic input parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic input parameters. Default: []</param>
		// Token: 0x06000B47 RID: 2887 RVA: 0x00047340 File Offset: 0x00045540
		public void DistanceObjectModel3d(HObjectModel3D objectModel3DTo, HPose pose, HTuple maxDistance, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1061);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, objectModel3DTo);
			HalconAPI.Store(proc, 2, pose);
			HalconAPI.Store(proc, 3, maxDistance);
			HalconAPI.Store(proc, 4, genParamName);
			HalconAPI.Store(proc, 5, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(pose);
			HalconAPI.UnpinTuple(maxDistance);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(objectModel3DTo);
		}

		/// <summary>
		///   Compute the distances of the points of one 3D object model to another 3D object model.
		///   Instance represents: Handle of the source 3D object model.
		/// </summary>
		/// <param name="objectModel3DTo">Handle of the target 3D object model.</param>
		/// <param name="pose">Pose of the source 3D object model in the target 3D object model. Default: []</param>
		/// <param name="maxDistance">Maximum distance of interest. Default: 0</param>
		/// <param name="genParamName">Names of the generic input parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic input parameters. Default: []</param>
		// Token: 0x06000B48 RID: 2888 RVA: 0x000473C8 File Offset: 0x000455C8
		public void DistanceObjectModel3d(HObjectModel3D objectModel3DTo, HPose pose, double maxDistance, string genParamName, string genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1061);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, objectModel3DTo);
			HalconAPI.Store(proc, 2, pose);
			HalconAPI.StoreD(proc, 3, maxDistance);
			HalconAPI.StoreS(proc, 4, genParamName);
			HalconAPI.StoreS(proc, 5, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(pose);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(objectModel3DTo);
		}

		/// <summary>Combine several 3D object models to a new 3D object model.</summary>
		/// <param name="objectModels3D">Handle of input 3D object models.</param>
		/// <param name="method">Method used for the union. Default: "points_surface"</param>
		/// <returns>Handle of the resulting 3D object model.</returns>
		// Token: 0x06000B49 RID: 2889 RVA: 0x0004743C File Offset: 0x0004563C
		public static HObjectModel3D UnionObjectModel3d(HObjectModel3D[] objectModels3D, string method)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModels3D);
			IntPtr proc = HalconAPI.PreCall(1062);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.StoreS(proc, 1, method);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModels3D);
			return result;
		}

		/// <summary>
		///   Combine several 3D object models to a new 3D object model.
		///   Instance represents: Handle of input 3D object models.
		/// </summary>
		/// <param name="method">Method used for the union. Default: "points_surface"</param>
		/// <returns>Handle of the resulting 3D object model.</returns>
		// Token: 0x06000B4A RID: 2890 RVA: 0x0004749C File Offset: 0x0004569C
		public HObjectModel3D UnionObjectModel3d(string method)
		{
			IntPtr proc = HalconAPI.PreCall(1062);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, method);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Set attributes of a 3D object model.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="attribName">Name of the attributes.</param>
		/// <param name="attachExtAttribTo">Defines where extended attributes are attached to. Default: []</param>
		/// <param name="attribValues">Attribute values.</param>
		// Token: 0x06000B4B RID: 2891 RVA: 0x000474EC File Offset: 0x000456EC
		public void SetObjectModel3dAttribMod(HTuple attribName, string attachExtAttribTo, HTuple attribValues)
		{
			IntPtr proc = HalconAPI.PreCall(1063);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, attribName);
			HalconAPI.StoreS(proc, 2, attachExtAttribTo);
			HalconAPI.Store(proc, 3, attribValues);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(attribName);
			HalconAPI.UnpinTuple(attribValues);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set attributes of a 3D object model.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="attribName">Name of the attributes.</param>
		/// <param name="attachExtAttribTo">Defines where extended attributes are attached to. Default: []</param>
		/// <param name="attribValues">Attribute values.</param>
		// Token: 0x06000B4C RID: 2892 RVA: 0x00047544 File Offset: 0x00045744
		public void SetObjectModel3dAttribMod(string attribName, string attachExtAttribTo, double attribValues)
		{
			IntPtr proc = HalconAPI.PreCall(1063);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, attribName);
			HalconAPI.StoreS(proc, 2, attachExtAttribTo);
			HalconAPI.StoreD(proc, 3, attribValues);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set attributes of a 3D object model.
		///   Instance represents: Handle of the input 3D object model.
		/// </summary>
		/// <param name="attribName">Name of the attributes.</param>
		/// <param name="attachExtAttribTo">Defines where extended attributes are attached to. Default: []</param>
		/// <param name="attribValues">Attribute values.</param>
		/// <returns>Handle of the resulting 3D object model.</returns>
		// Token: 0x06000B4D RID: 2893 RVA: 0x00047590 File Offset: 0x00045790
		public HObjectModel3D SetObjectModel3dAttrib(HTuple attribName, string attachExtAttribTo, HTuple attribValues)
		{
			IntPtr proc = HalconAPI.PreCall(1064);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, attribName);
			HalconAPI.StoreS(proc, 2, attachExtAttribTo);
			HalconAPI.Store(proc, 3, attribValues);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(attribName);
			HalconAPI.UnpinTuple(attribValues);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Set attributes of a 3D object model.
		///   Instance represents: Handle of the input 3D object model.
		/// </summary>
		/// <param name="attribName">Name of the attributes.</param>
		/// <param name="attachExtAttribTo">Defines where extended attributes are attached to. Default: []</param>
		/// <param name="attribValues">Attribute values.</param>
		/// <returns>Handle of the resulting 3D object model.</returns>
		// Token: 0x06000B4E RID: 2894 RVA: 0x000475FC File Offset: 0x000457FC
		public HObjectModel3D SetObjectModel3dAttrib(string attribName, string attachExtAttribTo, double attribValues)
		{
			IntPtr proc = HalconAPI.PreCall(1064);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, attribName);
			HalconAPI.StoreS(proc, 2, attachExtAttribTo);
			HalconAPI.StoreD(proc, 3, attribValues);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Create an empty 3D object model.
		///   Modified instance represents: Handle of the new 3D object model.
		/// </summary>
		// Token: 0x06000B4F RID: 2895 RVA: 0x0004765C File Offset: 0x0004585C
		public void GenEmptyObjectModel3d()
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1065);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>Sample a 3D object model.</summary>
		/// <param name="objectModel3D">Handle of the 3D object model to be sampled.</param>
		/// <param name="method">Selects between the different subsampling methods. Default: "fast"</param>
		/// <param name="sampleDistance">Sampling distance. Default: 0.05</param>
		/// <param name="genParamName">Names of the generic parameters that can be adjusted. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters that can be adjusted. Default: []</param>
		/// <returns>Handle of the 3D object model that contains the sampled points.</returns>
		// Token: 0x06000B50 RID: 2896 RVA: 0x000476A0 File Offset: 0x000458A0
		public static HObjectModel3D[] SampleObjectModel3d(HObjectModel3D[] objectModel3D, string method, HTuple sampleDistance, HTuple genParamName, HTuple genParamValue)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(1066);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.StoreS(proc, 1, method);
			HalconAPI.Store(proc, 2, sampleDistance);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(sampleDistance);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Sample a 3D object model.
		///   Instance represents: Handle of the 3D object model to be sampled.
		/// </summary>
		/// <param name="method">Selects between the different subsampling methods. Default: "fast"</param>
		/// <param name="sampleDistance">Sampling distance. Default: 0.05</param>
		/// <param name="genParamName">Names of the generic parameters that can be adjusted. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters that can be adjusted. Default: []</param>
		/// <returns>Handle of the 3D object model that contains the sampled points.</returns>
		// Token: 0x06000B51 RID: 2897 RVA: 0x0004772C File Offset: 0x0004592C
		public HObjectModel3D SampleObjectModel3d(string method, double sampleDistance, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1066);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, method);
			HalconAPI.StoreD(proc, 2, sampleDistance);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Improve the relative transformations between 3D object models based on their overlaps.</summary>
		/// <param name="objectModels3D">Handles of several 3D object models.</param>
		/// <param name="homMats3D">Approximate relative transformations between the 3D object models.</param>
		/// <param name="from">Type of interpretation for the transformations. Default: "global"</param>
		/// <param name="to">Target indices of the transformations if From specifies the source indices, otherwise the parameter must be empty. Default: []</param>
		/// <param name="genParamName">Names of the generic parameters that can be adjusted for the global 3D object model registration. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters that can be adjusted for the global 3D object model registration. Default: []</param>
		/// <param name="scores">Number of overlapping neighbors for each 3D object model.</param>
		/// <returns>Resulting Transformations.</returns>
		// Token: 0x06000B52 RID: 2898 RVA: 0x000477A4 File Offset: 0x000459A4
		public static HHomMat3D[] RegisterObjectModel3dGlobal(HObjectModel3D[] objectModels3D, HHomMat3D[] homMats3D, HTuple from, HTuple to, HTuple genParamName, HTuple genParamValue, out HTuple scores)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModels3D);
			HTuple htuple2 = HData.ConcatArray(homMats3D);
			IntPtr proc = HalconAPI.PreCall(1067);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, htuple2);
			HalconAPI.Store(proc, 2, from);
			HalconAPI.Store(proc, 3, to);
			HalconAPI.Store(proc, 4, genParamName);
			HalconAPI.Store(proc, 5, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(htuple2);
			HalconAPI.UnpinTuple(from);
			HalconAPI.UnpinTuple(to);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out scores);
			HalconAPI.PostCall(proc, num);
			HHomMat3D[] result = HHomMat3D.SplitArray(data);
			GC.KeepAlive(objectModels3D);
			return result;
		}

		/// <summary>
		///   Improve the relative transformations between 3D object models based on their overlaps.
		///   Instance represents: Handles of several 3D object models.
		/// </summary>
		/// <param name="homMats3D">Approximate relative transformations between the 3D object models.</param>
		/// <param name="from">Type of interpretation for the transformations. Default: "global"</param>
		/// <param name="to">Target indices of the transformations if From specifies the source indices, otherwise the parameter must be empty. Default: []</param>
		/// <param name="genParamName">Names of the generic parameters that can be adjusted for the global 3D object model registration. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters that can be adjusted for the global 3D object model registration. Default: []</param>
		/// <param name="scores">Number of overlapping neighbors for each 3D object model.</param>
		/// <returns>Resulting Transformations.</returns>
		// Token: 0x06000B53 RID: 2899 RVA: 0x0004786C File Offset: 0x00045A6C
		public HHomMat3D[] RegisterObjectModel3dGlobal(HHomMat3D[] homMats3D, string from, int to, HTuple genParamName, HTuple genParamValue, out HTuple scores)
		{
			HTuple htuple = HData.ConcatArray(homMats3D);
			IntPtr proc = HalconAPI.PreCall(1067);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, htuple);
			HalconAPI.StoreS(proc, 2, from);
			HalconAPI.StoreI(proc, 3, to);
			HalconAPI.Store(proc, 4, genParamName);
			HalconAPI.Store(proc, 5, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out scores);
			HalconAPI.PostCall(proc, num);
			HHomMat3D[] result = HHomMat3D.SplitArray(data);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Search for a transformation between two 3D object models.
		///   Instance represents: Handle of the first 3D object model.
		/// </summary>
		/// <param name="objectModel3D2">Handle of the second 3D object model.</param>
		/// <param name="method">Method for the registration. Default: "matching"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <param name="score">Overlapping of the two 3D object models.</param>
		/// <returns>Pose to transform ObjectModel3D1 in the reference frame of ObjectModel3D2.</returns>
		// Token: 0x06000B54 RID: 2900 RVA: 0x00047918 File Offset: 0x00045B18
		public HPose RegisterObjectModel3dPair(HObjectModel3D objectModel3D2, string method, HTuple genParamName, HTuple genParamValue, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(1068);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, objectModel3D2);
			HalconAPI.StoreS(proc, 2, method);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectModel3D2);
			return result;
		}

		/// <summary>
		///   Search for a transformation between two 3D object models.
		///   Instance represents: Handle of the first 3D object model.
		/// </summary>
		/// <param name="objectModel3D2">Handle of the second 3D object model.</param>
		/// <param name="method">Method for the registration. Default: "matching"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <param name="score">Overlapping of the two 3D object models.</param>
		/// <returns>Pose to transform ObjectModel3D1 in the reference frame of ObjectModel3D2.</returns>
		// Token: 0x06000B55 RID: 2901 RVA: 0x000479A8 File Offset: 0x00045BA8
		public HPose RegisterObjectModel3dPair(HObjectModel3D objectModel3D2, string method, string genParamName, double genParamValue, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(1068);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, objectModel3D2);
			HalconAPI.StoreS(proc, 2, method);
			HalconAPI.StoreS(proc, 3, genParamName);
			HalconAPI.StoreD(proc, 4, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectModel3D2);
			return result;
		}

		/// <summary>
		///   Create a 3D object model that represents a point cloud from a set of 3D points.
		///   Modified instance represents: Handle of the resulting 3D object model.
		/// </summary>
		/// <param name="x">The x-coordinates of the points in the 3D point cloud.</param>
		/// <param name="y">The y-coordinates of the points in the 3D point cloud.</param>
		/// <param name="z">The z-coordinates of the points in the 3D point cloud.</param>
		// Token: 0x06000B56 RID: 2902 RVA: 0x00047A2C File Offset: 0x00045C2C
		public void GenObjectModel3dFromPoints(HTuple x, HTuple y, HTuple z)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1069);
			HalconAPI.Store(proc, 0, x);
			HalconAPI.Store(proc, 1, y);
			HalconAPI.Store(proc, 2, z);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(x);
			HalconAPI.UnpinTuple(y);
			HalconAPI.UnpinTuple(z);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a 3D object model that represents a point cloud from a set of 3D points.
		///   Modified instance represents: Handle of the resulting 3D object model.
		/// </summary>
		/// <param name="x">The x-coordinates of the points in the 3D point cloud.</param>
		/// <param name="y">The y-coordinates of the points in the 3D point cloud.</param>
		/// <param name="z">The z-coordinates of the points in the 3D point cloud.</param>
		// Token: 0x06000B57 RID: 2903 RVA: 0x00047A9C File Offset: 0x00045C9C
		public void GenObjectModel3dFromPoints(double x, double y, double z)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1069);
			HalconAPI.StoreD(proc, 0, x);
			HalconAPI.StoreD(proc, 1, y);
			HalconAPI.StoreD(proc, 2, z);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>Create a 3D object model that represents a box.</summary>
		/// <param name="pose">The pose that describes the position and orientation of the box.  The pose has its origin in the center of the box.</param>
		/// <param name="lengthX">The length of the box along the x-axis.</param>
		/// <param name="lengthY">The length of the box along the y-axis.</param>
		/// <param name="lengthZ">The length of the box along the z-axis.</param>
		/// <returns>Handle of the resulting 3D object model.</returns>
		// Token: 0x06000B58 RID: 2904 RVA: 0x00047AF8 File Offset: 0x00045CF8
		public static HObjectModel3D[] GenBoxObjectModel3d(HPose[] pose, HTuple lengthX, HTuple lengthY, HTuple lengthZ)
		{
			HTuple htuple = HData.ConcatArray(pose);
			IntPtr proc = HalconAPI.PreCall(1070);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, lengthX);
			HalconAPI.Store(proc, 2, lengthY);
			HalconAPI.Store(proc, 3, lengthZ);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(lengthX);
			HalconAPI.UnpinTuple(lengthY);
			HalconAPI.UnpinTuple(lengthZ);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>
		///   Create a 3D object model that represents a box.
		///   Modified instance represents: Handle of the resulting 3D object model.
		/// </summary>
		/// <param name="pose">The pose that describes the position and orientation of the box.  The pose has its origin in the center of the box.</param>
		/// <param name="lengthX">The length of the box along the x-axis.</param>
		/// <param name="lengthY">The length of the box along the y-axis.</param>
		/// <param name="lengthZ">The length of the box along the z-axis.</param>
		// Token: 0x06000B59 RID: 2905 RVA: 0x00047B74 File Offset: 0x00045D74
		public void GenBoxObjectModel3d(HPose pose, double lengthX, double lengthY, double lengthZ)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1070);
			HalconAPI.Store(proc, 0, pose);
			HalconAPI.StoreD(proc, 1, lengthX);
			HalconAPI.StoreD(proc, 2, lengthY);
			HalconAPI.StoreD(proc, 3, lengthZ);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(pose);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a 3D object model that represents a plane.
		///   Modified instance represents: Handle of the resulting 3D object model.
		/// </summary>
		/// <param name="pose">The center and the rotation of the plane.</param>
		/// <param name="XExtent">x coordinates specifying the extent of the plane.</param>
		/// <param name="YExtent">y coordinates specifying the extent of the plane.</param>
		// Token: 0x06000B5A RID: 2906 RVA: 0x00047BEC File Offset: 0x00045DEC
		public void GenPlaneObjectModel3d(HPose pose, HTuple XExtent, HTuple YExtent)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1071);
			HalconAPI.Store(proc, 0, pose);
			HalconAPI.Store(proc, 1, XExtent);
			HalconAPI.Store(proc, 2, YExtent);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(pose);
			HalconAPI.UnpinTuple(XExtent);
			HalconAPI.UnpinTuple(YExtent);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a 3D object model that represents a plane.
		///   Modified instance represents: Handle of the resulting 3D object model.
		/// </summary>
		/// <param name="pose">The center and the rotation of the plane.</param>
		/// <param name="XExtent">x coordinates specifying the extent of the plane.</param>
		/// <param name="YExtent">y coordinates specifying the extent of the plane.</param>
		// Token: 0x06000B5B RID: 2907 RVA: 0x00047C64 File Offset: 0x00045E64
		public void GenPlaneObjectModel3d(HPose pose, double XExtent, double YExtent)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1071);
			HalconAPI.Store(proc, 0, pose);
			HalconAPI.StoreD(proc, 1, XExtent);
			HalconAPI.StoreD(proc, 2, YExtent);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(pose);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>Create a 3D object model that represents a sphere from x,y,z coordinates.</summary>
		/// <param name="x">The x-coordinate of the center point of the sphere.</param>
		/// <param name="y">The y-coordinate of the center point of the sphere.</param>
		/// <param name="z">The z-coordinate of the center point of the sphere.</param>
		/// <param name="radius">The radius of the sphere.</param>
		/// <returns>Handle of the resulting 3D object model.</returns>
		// Token: 0x06000B5C RID: 2908 RVA: 0x00047CD0 File Offset: 0x00045ED0
		public static HObjectModel3D[] GenSphereObjectModel3dCenter(HTuple x, HTuple y, HTuple z, HTuple radius)
		{
			IntPtr proc = HalconAPI.PreCall(1072);
			HalconAPI.Store(proc, 0, x);
			HalconAPI.Store(proc, 1, y);
			HalconAPI.Store(proc, 2, z);
			HalconAPI.Store(proc, 3, radius);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(x);
			HalconAPI.UnpinTuple(y);
			HalconAPI.UnpinTuple(z);
			HalconAPI.UnpinTuple(radius);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>
		///   Create a 3D object model that represents a sphere from x,y,z coordinates.
		///   Modified instance represents: Handle of the resulting 3D object model.
		/// </summary>
		/// <param name="x">The x-coordinate of the center point of the sphere.</param>
		/// <param name="y">The y-coordinate of the center point of the sphere.</param>
		/// <param name="z">The z-coordinate of the center point of the sphere.</param>
		/// <param name="radius">The radius of the sphere.</param>
		// Token: 0x06000B5D RID: 2909 RVA: 0x00047D40 File Offset: 0x00045F40
		public void GenSphereObjectModel3dCenter(double x, double y, double z, double radius)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1072);
			HalconAPI.StoreD(proc, 0, x);
			HalconAPI.StoreD(proc, 1, y);
			HalconAPI.StoreD(proc, 2, z);
			HalconAPI.StoreD(proc, 3, radius);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>Create a 3D object model that represents a sphere.</summary>
		/// <param name="pose">The pose that describes the position of the sphere.</param>
		/// <param name="radius">The radius of the sphere.</param>
		/// <returns>Handle of the resulting 3D object model.</returns>
		// Token: 0x06000B5E RID: 2910 RVA: 0x00047DA8 File Offset: 0x00045FA8
		public static HObjectModel3D[] GenSphereObjectModel3d(HPose[] pose, HTuple radius)
		{
			HTuple htuple = HData.ConcatArray(pose);
			IntPtr proc = HalconAPI.PreCall(1073);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, radius);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(radius);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>
		///   Create a 3D object model that represents a sphere.
		///   Modified instance represents: Handle of the resulting 3D object model.
		/// </summary>
		/// <param name="pose">The pose that describes the position of the sphere.</param>
		/// <param name="radius">The radius of the sphere.</param>
		// Token: 0x06000B5F RID: 2911 RVA: 0x00047E08 File Offset: 0x00046008
		public void GenSphereObjectModel3d(HPose pose, double radius)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1073);
			HalconAPI.Store(proc, 0, pose);
			HalconAPI.StoreD(proc, 1, radius);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(pose);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>Create a 3D object model that represents a cylinder.</summary>
		/// <param name="pose">The pose that describes the position and orientation of the cylinder.</param>
		/// <param name="radius">The radius of the cylinder.</param>
		/// <param name="minExtent">Lowest z-coordinate of the cylinder in the direction of the rotation axis.</param>
		/// <param name="maxExtent">Highest z-coordinate of the cylinder in the direction of the rotation axis.</param>
		/// <returns>Handle of the resulting 3D object model.</returns>
		// Token: 0x06000B60 RID: 2912 RVA: 0x00047E6C File Offset: 0x0004606C
		public static HObjectModel3D[] GenCylinderObjectModel3d(HPose[] pose, HTuple radius, HTuple minExtent, HTuple maxExtent)
		{
			HTuple htuple = HData.ConcatArray(pose);
			IntPtr proc = HalconAPI.PreCall(1074);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, radius);
			HalconAPI.Store(proc, 2, minExtent);
			HalconAPI.Store(proc, 3, maxExtent);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(radius);
			HalconAPI.UnpinTuple(minExtent);
			HalconAPI.UnpinTuple(maxExtent);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>
		///   Create a 3D object model that represents a cylinder.
		///   Modified instance represents: Handle of the resulting 3D object model.
		/// </summary>
		/// <param name="pose">The pose that describes the position and orientation of the cylinder.</param>
		/// <param name="radius">The radius of the cylinder.</param>
		/// <param name="minExtent">Lowest z-coordinate of the cylinder in the direction of the rotation axis.</param>
		/// <param name="maxExtent">Highest z-coordinate of the cylinder in the direction of the rotation axis.</param>
		// Token: 0x06000B61 RID: 2913 RVA: 0x00047EE8 File Offset: 0x000460E8
		public void GenCylinderObjectModel3d(HPose pose, double radius, double minExtent, double maxExtent)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1074);
			HalconAPI.Store(proc, 0, pose);
			HalconAPI.StoreD(proc, 1, radius);
			HalconAPI.StoreD(proc, 2, minExtent);
			HalconAPI.StoreD(proc, 3, maxExtent);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(pose);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>Calculate the smallest bounding box around the points of a 3D object model.</summary>
		/// <param name="objectModel3D">Handle of the 3D object model.</param>
		/// <param name="type">The method that is used to estimate the smallest box. Default: "oriented"</param>
		/// <param name="length1">The length of the longest side of the box.</param>
		/// <param name="length2">The length of the second longest side of the box.</param>
		/// <param name="length3">The length of the third longest side of the box.</param>
		/// <returns>The pose that describes the position and orientation of the box that is generated. The pose has its origin in the center of the box and is oriented such that the x-axis is aligned with the longest side of the box.</returns>
		// Token: 0x06000B62 RID: 2914 RVA: 0x00047F60 File Offset: 0x00046160
		public static HPose[] SmallestBoundingBoxObjectModel3d(HObjectModel3D[] objectModel3D, string type, out HTuple length1, out HTuple length2, out HTuple length3)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(1075);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.StoreS(proc, 1, type);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out length1);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out length2);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out length3);
			HalconAPI.PostCall(proc, num);
			HPose[] result = HPose.SplitArray(data);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Calculate the smallest bounding box around the points of a 3D object model.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="type">The method that is used to estimate the smallest box. Default: "oriented"</param>
		/// <param name="length1">The length of the longest side of the box.</param>
		/// <param name="length2">The length of the second longest side of the box.</param>
		/// <param name="length3">The length of the third longest side of the box.</param>
		/// <returns>The pose that describes the position and orientation of the box that is generated. The pose has its origin in the center of the box and is oriented such that the x-axis is aligned with the longest side of the box.</returns>
		// Token: 0x06000B63 RID: 2915 RVA: 0x00047FFC File Offset: 0x000461FC
		public HPose SmallestBoundingBoxObjectModel3d(string type, out double length1, out double length2, out double length3)
		{
			IntPtr proc = HalconAPI.PreCall(1075);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, type);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out length1);
			num = HalconAPI.LoadD(proc, 2, num, out length2);
			num = HalconAPI.LoadD(proc, 3, num, out length3);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Calculate the smallest sphere around the points of a 3D object model.</summary>
		/// <param name="objectModel3D">Handle of the 3D object model.</param>
		/// <param name="radius">The estimated radius of the sphere.</param>
		/// <returns>x-, y-, and z-coordinates describing the center point of the sphere.</returns>
		// Token: 0x06000B64 RID: 2916 RVA: 0x00048084 File Offset: 0x00046284
		public static HTuple SmallestSphereObjectModel3d(HObjectModel3D[] objectModel3D, out HTuple radius)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(1076);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out radius);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Calculate the smallest sphere around the points of a 3D object model.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="radius">The estimated radius of the sphere.</param>
		/// <returns>x-, y-, and z-coordinates describing the center point of the sphere.</returns>
		// Token: 0x06000B65 RID: 2917 RVA: 0x000480F0 File Offset: 0x000462F0
		public HTuple SmallestSphereObjectModel3d(out double radius)
		{
			IntPtr proc = HalconAPI.PreCall(1076);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out radius);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Intersect a 3D object model with a plane.</summary>
		/// <param name="objectModel3D">Handle of the 3D object model.</param>
		/// <param name="plane">Pose of the plane. Default: [0,0,0,0,0,0,0]</param>
		/// <returns>Handle of the 3D object model that describes the intersection as a set of lines.</returns>
		// Token: 0x06000B66 RID: 2918 RVA: 0x0004814C File Offset: 0x0004634C
		public static HObjectModel3D[] IntersectPlaneObjectModel3d(HObjectModel3D[] objectModel3D, HPose[] plane)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			HTuple htuple2 = HData.ConcatArray(plane);
			IntPtr proc = HalconAPI.PreCall(1077);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, htuple2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(htuple2);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Intersect a 3D object model with a plane.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="plane">Pose of the plane. Default: [0,0,0,0,0,0,0]</param>
		/// <returns>Handle of the 3D object model that describes the intersection as a set of lines.</returns>
		// Token: 0x06000B67 RID: 2919 RVA: 0x000481BC File Offset: 0x000463BC
		public HObjectModel3D IntersectPlaneObjectModel3d(HPose plane)
		{
			IntPtr proc = HalconAPI.PreCall(1077);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, plane);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(plane);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Calculate the convex hull of a 3D object model. </summary>
		/// <param name="objectModel3D">Handle of the 3D object model.</param>
		/// <returns>Handle of the 3D object model that describes the convex hull.</returns>
		// Token: 0x06000B68 RID: 2920 RVA: 0x0004821C File Offset: 0x0004641C
		public static HObjectModel3D[] ConvexHullObjectModel3d(HObjectModel3D[] objectModel3D)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(1078);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Calculate the convex hull of a 3D object model. 
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <returns>Handle of the 3D object model that describes the convex hull.</returns>
		// Token: 0x06000B69 RID: 2921 RVA: 0x00048274 File Offset: 0x00046474
		public HObjectModel3D ConvexHullObjectModel3d()
		{
			IntPtr proc = HalconAPI.PreCall(1078);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Select 3D object models from an array of 3D object models according to global features.</summary>
		/// <param name="objectModel3D">Handles of the available 3D object models to select.</param>
		/// <param name="feature">List of features a test is performed on. Default: "has_triangles"</param>
		/// <param name="operation">Logical operation to combine the features given in Feature. Default: "and"</param>
		/// <param name="minValue">Minimum value for the given feature. Default: 1</param>
		/// <param name="maxValue">Maximum value for the given feature. Default: 1</param>
		/// <returns>A subset of ObjectModel3D fulfilling the given conditions.</returns>
		// Token: 0x06000B6A RID: 2922 RVA: 0x000482BC File Offset: 0x000464BC
		public static HObjectModel3D[] SelectObjectModel3d(HObjectModel3D[] objectModel3D, HTuple feature, string operation, HTuple minValue, HTuple maxValue)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(1079);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, feature);
			HalconAPI.StoreS(proc, 2, operation);
			HalconAPI.Store(proc, 3, minValue);
			HalconAPI.Store(proc, 4, maxValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(feature);
			HalconAPI.UnpinTuple(minValue);
			HalconAPI.UnpinTuple(maxValue);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Select 3D object models from an array of 3D object models according to global features.
		///   Instance represents: Handles of the available 3D object models to select.
		/// </summary>
		/// <param name="feature">List of features a test is performed on. Default: "has_triangles"</param>
		/// <param name="operation">Logical operation to combine the features given in Feature. Default: "and"</param>
		/// <param name="minValue">Minimum value for the given feature. Default: 1</param>
		/// <param name="maxValue">Maximum value for the given feature. Default: 1</param>
		/// <returns>A subset of ObjectModel3D fulfilling the given conditions.</returns>
		// Token: 0x06000B6B RID: 2923 RVA: 0x00048348 File Offset: 0x00046548
		public HObjectModel3D SelectObjectModel3d(string feature, string operation, double minValue, double maxValue)
		{
			IntPtr proc = HalconAPI.PreCall(1079);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, feature);
			HalconAPI.StoreS(proc, 2, operation);
			HalconAPI.StoreD(proc, 3, minValue);
			HalconAPI.StoreD(proc, 4, maxValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Calculate the area of all faces of a 3D object model.</summary>
		/// <param name="objectModel3D">Handle of the 3D object model.</param>
		/// <returns>Calculated area.</returns>
		// Token: 0x06000B6C RID: 2924 RVA: 0x000483B4 File Offset: 0x000465B4
		public static HTuple AreaObjectModel3d(HObjectModel3D[] objectModel3D)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(1080);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Calculate the area of all faces of a 3D object model.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <returns>Calculated area.</returns>
		// Token: 0x06000B6D RID: 2925 RVA: 0x0004840C File Offset: 0x0004660C
		public double AreaObjectModel3d()
		{
			IntPtr proc = HalconAPI.PreCall(1080);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Calculate the maximal diameter of a 3D object model.</summary>
		/// <param name="objectModel3D">Handle of the 3D object model.</param>
		/// <returns>Calculated diameter.</returns>
		// Token: 0x06000B6E RID: 2926 RVA: 0x00048454 File Offset: 0x00046654
		public static HTuple MaxDiameterObjectModel3d(HObjectModel3D[] objectModel3D)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(1081);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Calculate the maximal diameter of a 3D object model.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <returns>Calculated diameter.</returns>
		// Token: 0x06000B6F RID: 2927 RVA: 0x000484AC File Offset: 0x000466AC
		public double MaxDiameterObjectModel3d()
		{
			IntPtr proc = HalconAPI.PreCall(1081);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Calculates the mean or the central moment of second order for a 3D object model.</summary>
		/// <param name="objectModel3D">Handle of the 3D object model.</param>
		/// <param name="momentsToCalculate">Moment to calculate. Default: "mean_points"</param>
		/// <returns>Calculated moment.</returns>
		// Token: 0x06000B70 RID: 2928 RVA: 0x000484F4 File Offset: 0x000466F4
		public static HTuple MomentsObjectModel3d(HObjectModel3D[] objectModel3D, HTuple momentsToCalculate)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(1082);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, momentsToCalculate);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(momentsToCalculate);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Calculates the mean or the central moment of second order for a 3D object model.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="momentsToCalculate">Moment to calculate. Default: "mean_points"</param>
		/// <returns>Calculated moment.</returns>
		// Token: 0x06000B71 RID: 2929 RVA: 0x00048558 File Offset: 0x00046758
		public double MomentsObjectModel3d(string momentsToCalculate)
		{
			IntPtr proc = HalconAPI.PreCall(1082);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, momentsToCalculate);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Calculate the volume of a 3D object model.</summary>
		/// <param name="objectModel3D">Handle of the 3D object model.</param>
		/// <param name="plane">Pose of the plane. Default: [0,0,0,0,0,0,0]</param>
		/// <param name="mode">Method to combine volumes laying above and below the reference plane. Default: "signed"</param>
		/// <param name="useFaceOrientation">Decides whether the orientation of a face should affect the resulting sign of the underlying volume. Default: "true"</param>
		/// <returns>Absolute value of the calculated volume.</returns>
		// Token: 0x06000B72 RID: 2930 RVA: 0x000485A8 File Offset: 0x000467A8
		public static HTuple VolumeObjectModel3dRelativeToPlane(HObjectModel3D[] objectModel3D, HPose[] plane, HTuple mode, HTuple useFaceOrientation)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			HTuple htuple2 = HData.ConcatArray(plane);
			IntPtr proc = HalconAPI.PreCall(1083);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, htuple2);
			HalconAPI.Store(proc, 2, mode);
			HalconAPI.Store(proc, 3, useFaceOrientation);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(htuple2);
			HalconAPI.UnpinTuple(mode);
			HalconAPI.UnpinTuple(useFaceOrientation);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Calculate the volume of a 3D object model.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="plane">Pose of the plane. Default: [0,0,0,0,0,0,0]</param>
		/// <param name="mode">Method to combine volumes laying above and below the reference plane. Default: "signed"</param>
		/// <param name="useFaceOrientation">Decides whether the orientation of a face should affect the resulting sign of the underlying volume. Default: "true"</param>
		/// <returns>Absolute value of the calculated volume.</returns>
		// Token: 0x06000B73 RID: 2931 RVA: 0x00048638 File Offset: 0x00046838
		public double VolumeObjectModel3dRelativeToPlane(HPose plane, string mode, string useFaceOrientation)
		{
			IntPtr proc = HalconAPI.PreCall(1083);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, plane);
			HalconAPI.StoreS(proc, 2, mode);
			HalconAPI.StoreS(proc, 3, useFaceOrientation);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(plane);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Remove points from a 3D object model by projecting it to a virtual view and removing all points outside of a given region.</summary>
		/// <param name="region">Region in the image plane.</param>
		/// <param name="objectModel3D">Handle of the 3D object model.</param>
		/// <param name="camParam">Internal camera parameters.</param>
		/// <param name="pose">3D pose of the world coordinate system in camera coordinates.</param>
		/// <returns>Handle of the reduced 3D object model.</returns>
		// Token: 0x06000B74 RID: 2932 RVA: 0x000486A8 File Offset: 0x000468A8
		public static HObjectModel3D[] ReduceObjectModel3dByView(HRegion region, HObjectModel3D[] objectModel3D, HCamPar camParam, HPose[] pose)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			HTuple htuple2 = HData.ConcatArray(pose);
			IntPtr proc = HalconAPI.PreCall(1084);
			HalconAPI.Store(proc, 1, region);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, camParam);
			HalconAPI.Store(proc, 2, htuple2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(htuple2);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(region);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Remove points from a 3D object model by projecting it to a virtual view and removing all points outside of a given region.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="region">Region in the image plane.</param>
		/// <param name="camParam">Internal camera parameters.</param>
		/// <param name="pose">3D pose of the world coordinate system in camera coordinates.</param>
		/// <returns>Handle of the reduced 3D object model.</returns>
		// Token: 0x06000B75 RID: 2933 RVA: 0x00048740 File Offset: 0x00046940
		public HObjectModel3D ReduceObjectModel3dByView(HRegion region, HCamPar camParam, HPose pose)
		{
			IntPtr proc = HalconAPI.PreCall(1084);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, region);
			HalconAPI.Store(proc, 1, camParam);
			HalconAPI.Store(proc, 2, pose);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(pose);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region);
			return result;
		}

		/// <summary>Determine the connected components of the 3D object model.</summary>
		/// <param name="objectModel3D">Handle of the 3D object model.</param>
		/// <param name="feature">Attribute used to calculate the connected components. Default: "distance_3d"</param>
		/// <param name="value">Maximum value for the distance between two connected components. Default: 1.0</param>
		/// <returns>Handle of the 3D object models that represent the connected components.</returns>
		// Token: 0x06000B76 RID: 2934 RVA: 0x000487C8 File Offset: 0x000469C8
		public static HObjectModel3D[] ConnectionObjectModel3d(HObjectModel3D[] objectModel3D, HTuple feature, HTuple value)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(1085);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, feature);
			HalconAPI.Store(proc, 2, value);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(feature);
			HalconAPI.UnpinTuple(value);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Determine the connected components of the 3D object model.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="feature">Attribute used to calculate the connected components. Default: "distance_3d"</param>
		/// <param name="value">Maximum value for the distance between two connected components. Default: 1.0</param>
		/// <returns>Handle of the 3D object models that represent the connected components.</returns>
		// Token: 0x06000B77 RID: 2935 RVA: 0x0004883C File Offset: 0x00046A3C
		public HObjectModel3D[] ConnectionObjectModel3d(string feature, double value)
		{
			IntPtr proc = HalconAPI.PreCall(1085);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, feature);
			HalconAPI.StoreD(proc, 2, value);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Apply a threshold to an attribute of 3D object models.</summary>
		/// <param name="objectModel3D">Handle of the 3D object models.</param>
		/// <param name="attrib">Attributes the threshold is applied to. Default: "point_coord_z"</param>
		/// <param name="minValue">Minimum value for the attributes specified by Attrib. Default: 0.5</param>
		/// <param name="maxValue">Maximum value for the attributes specified by Attrib. Default: 1.0</param>
		/// <returns>Handle of the reduced 3D object models.</returns>
		// Token: 0x06000B78 RID: 2936 RVA: 0x00048894 File Offset: 0x00046A94
		public static HObjectModel3D[] SelectPointsObjectModel3d(HObjectModel3D[] objectModel3D, HTuple attrib, HTuple minValue, HTuple maxValue)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(1086);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, attrib);
			HalconAPI.Store(proc, 2, minValue);
			HalconAPI.Store(proc, 3, maxValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(attrib);
			HalconAPI.UnpinTuple(minValue);
			HalconAPI.UnpinTuple(maxValue);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Apply a threshold to an attribute of 3D object models.
		///   Instance represents: Handle of the 3D object models.
		/// </summary>
		/// <param name="attrib">Attributes the threshold is applied to. Default: "point_coord_z"</param>
		/// <param name="minValue">Minimum value for the attributes specified by Attrib. Default: 0.5</param>
		/// <param name="maxValue">Maximum value for the attributes specified by Attrib. Default: 1.0</param>
		/// <returns>Handle of the reduced 3D object models.</returns>
		// Token: 0x06000B79 RID: 2937 RVA: 0x00048914 File Offset: 0x00046B14
		public HObjectModel3D SelectPointsObjectModel3d(string attrib, double minValue, double maxValue)
		{
			IntPtr proc = HalconAPI.PreCall(1086);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, attrib);
			HalconAPI.StoreD(proc, 2, minValue);
			HalconAPI.StoreD(proc, 3, maxValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Get the depth or the index of a displayed 3D object model.</summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="row">Row coordinates.</param>
		/// <param name="column">Column coordinates.</param>
		/// <param name="information">Information. Default: "depth"</param>
		/// <returns>Indices or the depth of the objects at (Row,Column).</returns>
		// Token: 0x06000B7A RID: 2938 RVA: 0x00048974 File Offset: 0x00046B74
		public static HTuple GetDispObjectModel3dInfo(HWindow windowHandle, HTuple row, HTuple column, HTuple information)
		{
			IntPtr proc = HalconAPI.PreCall(1087);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, column);
			HalconAPI.Store(proc, 3, information);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(information);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(windowHandle);
			return result;
		}

		/// <summary>Get the depth or the index of a displayed 3D object model.</summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="row">Row coordinates.</param>
		/// <param name="column">Column coordinates.</param>
		/// <param name="information">Information. Default: "depth"</param>
		/// <returns>Indices or the depth of the objects at (Row,Column).</returns>
		// Token: 0x06000B7B RID: 2939 RVA: 0x000489E4 File Offset: 0x00046BE4
		public static int GetDispObjectModel3dInfo(HWindow windowHandle, double row, double column, string information)
		{
			IntPtr proc = HalconAPI.PreCall(1087);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.StoreD(proc, 1, row);
			HalconAPI.StoreD(proc, 2, column);
			HalconAPI.StoreS(proc, 3, information);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(windowHandle);
			return result;
		}

		/// <summary>Render 3D object models to get an image.</summary>
		/// <param name="objectModel3D">Handles of the 3D object models.</param>
		/// <param name="camParam">Camera parameters of the scene.</param>
		/// <param name="pose">3D poses of the objects.</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Rendered scene.</returns>
		// Token: 0x06000B7C RID: 2940 RVA: 0x00048A44 File Offset: 0x00046C44
		public static HImage RenderObjectModel3d(HObjectModel3D[] objectModel3D, HCamPar camParam, HPose[] pose, HTuple genParamName, HTuple genParamValue)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			HTuple htuple2 = HData.ConcatArray(pose);
			IntPtr proc = HalconAPI.PreCall(1088);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, camParam);
			HalconAPI.Store(proc, 2, htuple2);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(htuple2);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Render 3D object models to get an image.
		///   Instance represents: Handles of the 3D object models.
		/// </summary>
		/// <param name="camParam">Camera parameters of the scene.</param>
		/// <param name="pose">3D poses of the objects.</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Rendered scene.</returns>
		// Token: 0x06000B7D RID: 2941 RVA: 0x00048AEC File Offset: 0x00046CEC
		public HImage RenderObjectModel3d(HCamPar camParam, HPose pose, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1088);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, camParam);
			HalconAPI.Store(proc, 2, pose);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(pose);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Display 3D object models.</summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="objectModel3D">Handles of the 3D object models.</param>
		/// <param name="camParam">Camera parameters of the scene. Default: []</param>
		/// <param name="pose">3D poses of the objects. Default: []</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		// Token: 0x06000B7E RID: 2942 RVA: 0x00048B84 File Offset: 0x00046D84
		public static void DispObjectModel3d(HWindow windowHandle, HObjectModel3D[] objectModel3D, HCamPar camParam, HPose[] pose, HTuple genParamName, HTuple genParamValue)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			HTuple htuple2 = HData.ConcatArray(pose);
			IntPtr proc = HalconAPI.PreCall(1089);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.Store(proc, 1, htuple);
			HalconAPI.Store(proc, 2, camParam);
			HalconAPI.Store(proc, 3, htuple2);
			HalconAPI.Store(proc, 4, genParamName);
			HalconAPI.Store(proc, 5, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(htuple2);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(windowHandle);
			GC.KeepAlive(objectModel3D);
		}

		/// <summary>
		///   Display 3D object models.
		///   Instance represents: Handles of the 3D object models.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="camParam">Camera parameters of the scene. Default: []</param>
		/// <param name="pose">3D poses of the objects. Default: []</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		// Token: 0x06000B7F RID: 2943 RVA: 0x00048C24 File Offset: 0x00046E24
		public void DispObjectModel3d(HWindow windowHandle, HCamPar camParam, HPose pose, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1089);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.Store(proc, 2, camParam);
			HalconAPI.Store(proc, 3, pose);
			HalconAPI.Store(proc, 4, genParamName);
			HalconAPI.Store(proc, 5, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(pose);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Copy a 3D object model.
		///   Instance represents: Handle of the input 3D object model.
		/// </summary>
		/// <param name="attributes">Attributes to be copied. Default: "all"</param>
		/// <returns>Handle of the copied 3D object model.</returns>
		// Token: 0x06000B80 RID: 2944 RVA: 0x00048CB8 File Offset: 0x00046EB8
		public HObjectModel3D CopyObjectModel3d(HTuple attributes)
		{
			IntPtr proc = HalconAPI.PreCall(1090);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, attributes);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(attributes);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Copy a 3D object model.
		///   Instance represents: Handle of the input 3D object model.
		/// </summary>
		/// <param name="attributes">Attributes to be copied. Default: "all"</param>
		/// <returns>Handle of the copied 3D object model.</returns>
		// Token: 0x06000B81 RID: 2945 RVA: 0x00048D10 File Offset: 0x00046F10
		public HObjectModel3D CopyObjectModel3d(string attributes)
		{
			IntPtr proc = HalconAPI.PreCall(1090);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, attributes);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Prepare a 3D object model for a certain operation.</summary>
		/// <param name="objectModel3D">Handle of the 3D object model.</param>
		/// <param name="purpose">Purpose of the 3D object model. Default: "shape_based_matching_3d"</param>
		/// <param name="overwriteData">Specify if already existing data should be overwritten. Default: "true"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		// Token: 0x06000B82 RID: 2946 RVA: 0x00048D60 File Offset: 0x00046F60
		public static void PrepareObjectModel3d(HObjectModel3D[] objectModel3D, string purpose, string overwriteData, HTuple genParamName, HTuple genParamValue)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(1091);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.StoreS(proc, 1, purpose);
			HalconAPI.StoreS(proc, 2, overwriteData);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(objectModel3D);
		}

		/// <summary>
		///   Prepare a 3D object model for a certain operation.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="purpose">Purpose of the 3D object model. Default: "shape_based_matching_3d"</param>
		/// <param name="overwriteData">Specify if already existing data should be overwritten. Default: "true"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		// Token: 0x06000B83 RID: 2947 RVA: 0x00048DD0 File Offset: 0x00046FD0
		public void PrepareObjectModel3d(string purpose, string overwriteData, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1091);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, purpose);
			HalconAPI.StoreS(proc, 2, overwriteData);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>Transform 3D points from a 3D object model to images.</summary>
		/// <param name="y">Image with the Y-Coordinates of the 3D points.</param>
		/// <param name="z">Image with the Z-Coordinates of the 3D points.</param>
		/// <param name="objectModel3D">Handle of the 3D object model.</param>
		/// <param name="type">Type of the conversion. Default: "cartesian"</param>
		/// <param name="camParam">Camera parameters.</param>
		/// <param name="pose">Pose of the 3D object model.</param>
		/// <returns>Image with the X-Coordinates of the 3D points.</returns>
		// Token: 0x06000B84 RID: 2948 RVA: 0x00048E34 File Offset: 0x00047034
		public static HImage ObjectModel3dToXyz(out HImage y, out HImage z, HObjectModel3D[] objectModel3D, string type, HCamPar camParam, HPose pose)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(1092);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.StoreS(proc, 1, type);
			HalconAPI.Store(proc, 2, camParam);
			HalconAPI.Store(proc, 3, pose);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(pose);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out y);
			num = HImage.LoadNew(proc, 3, num, out z);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Transform 3D points from a 3D object model to images.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="y">Image with the Y-Coordinates of the 3D points.</param>
		/// <param name="z">Image with the Z-Coordinates of the 3D points.</param>
		/// <param name="type">Type of the conversion. Default: "cartesian"</param>
		/// <param name="camParam">Camera parameters.</param>
		/// <param name="pose">Pose of the 3D object model.</param>
		/// <returns>Image with the X-Coordinates of the 3D points.</returns>
		// Token: 0x06000B85 RID: 2949 RVA: 0x00048EEC File Offset: 0x000470EC
		public HImage ObjectModel3dToXyz(out HImage y, out HImage z, string type, HCamPar camParam, HPose pose)
		{
			IntPtr proc = HalconAPI.PreCall(1092);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, type);
			HalconAPI.Store(proc, 2, camParam);
			HalconAPI.Store(proc, 3, pose);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(pose);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out y);
			num = HImage.LoadNew(proc, 3, num, out z);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform 3D points from images to a 3D object model.
		///   Modified instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="x">Image with the X-Coordinates and the ROI of the 3D points.</param>
		/// <param name="y">Image with the Y-Coordinates of the 3D points.</param>
		/// <param name="z">Image with the Z-Coordinates of the 3D points.</param>
		// Token: 0x06000B86 RID: 2950 RVA: 0x00048F94 File Offset: 0x00047194
		public void XyzToObjectModel3d(HImage x, HImage y, HImage z)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1093);
			HalconAPI.Store(proc, 1, x);
			HalconAPI.Store(proc, 2, y);
			HalconAPI.Store(proc, 3, z);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(x);
			GC.KeepAlive(y);
			GC.KeepAlive(z);
		}

		/// <summary>Return attributes of 3D object models.</summary>
		/// <param name="objectModel3D">Handle of the 3D object model.</param>
		/// <param name="genParamName">Names of the generic attributes that are queried for the 3D object model. Default: "num_points"</param>
		/// <returns>Values of the generic parameters.</returns>
		// Token: 0x06000B87 RID: 2951 RVA: 0x00049004 File Offset: 0x00047204
		public static HTuple GetObjectModel3dParams(HObjectModel3D[] objectModel3D, HTuple genParamName)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(1094);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(genParamName);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Return attributes of 3D object models.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="genParamName">Names of the generic attributes that are queried for the 3D object model. Default: "num_points"</param>
		/// <returns>Values of the generic parameters.</returns>
		// Token: 0x06000B88 RID: 2952 RVA: 0x00049068 File Offset: 0x00047268
		public HTuple GetObjectModel3dParams(HTuple genParamName)
		{
			IntPtr proc = HalconAPI.PreCall(1094);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Project a 3D object model into image coordinates.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="camParam">Internal camera parameters.</param>
		/// <param name="pose">3D pose of the world coordinate system in camera coordinates.</param>
		/// <param name="genParamName">Name of the generic parameter. Default: []</param>
		/// <param name="genParamValue">Value of the generic parameter. Default: []</param>
		/// <returns>Projected model contours.</returns>
		// Token: 0x06000B89 RID: 2953 RVA: 0x000490C0 File Offset: 0x000472C0
		public HXLDCont ProjectObjectModel3d(HCamPar camParam, HPose pose, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1095);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, camParam);
			HalconAPI.Store(proc, 2, pose);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(pose);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Project a 3D object model into image coordinates.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="camParam">Internal camera parameters.</param>
		/// <param name="pose">3D pose of the world coordinate system in camera coordinates.</param>
		/// <param name="genParamName">Name of the generic parameter. Default: []</param>
		/// <param name="genParamValue">Value of the generic parameter. Default: []</param>
		/// <returns>Projected model contours.</returns>
		// Token: 0x06000B8A RID: 2954 RVA: 0x00049158 File Offset: 0x00047358
		public HXLDCont ProjectObjectModel3d(HCamPar camParam, HPose pose, string genParamName, string genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1095);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, camParam);
			HalconAPI.Store(proc, 2, pose);
			HalconAPI.StoreS(proc, 3, genParamName);
			HalconAPI.StoreS(proc, 4, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(pose);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Apply a rigid 3D transformation to 3D object models.</summary>
		/// <param name="objectModel3D">Handles of the 3D object models.</param>
		/// <param name="pose">Poses.</param>
		/// <returns>Handles of the transformed 3D object models.</returns>
		// Token: 0x06000B8B RID: 2955 RVA: 0x000491E4 File Offset: 0x000473E4
		public static HObjectModel3D[] RigidTransObjectModel3d(HObjectModel3D[] objectModel3D, HPose[] pose)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			HTuple htuple2 = HData.ConcatArray(pose);
			IntPtr proc = HalconAPI.PreCall(1096);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, htuple2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(htuple2);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Apply a rigid 3D transformation to 3D object models.
		///   Instance represents: Handles of the 3D object models.
		/// </summary>
		/// <param name="pose">Poses.</param>
		/// <returns>Handles of the transformed 3D object models.</returns>
		// Token: 0x06000B8C RID: 2956 RVA: 0x00049254 File Offset: 0x00047454
		public HObjectModel3D RigidTransObjectModel3d(HPose pose)
		{
			IntPtr proc = HalconAPI.PreCall(1096);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, pose);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(pose);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Apply an arbitrary projective 3D transformation to 3D object models.</summary>
		/// <param name="objectModel3D">Handles of the 3D object models.</param>
		/// <param name="homMat3D">Homogeneous projective transformation matrix.</param>
		/// <returns>Handles of the transformed 3D object models.</returns>
		// Token: 0x06000B8D RID: 2957 RVA: 0x000492B4 File Offset: 0x000474B4
		public static HObjectModel3D[] ProjectiveTransObjectModel3d(HObjectModel3D[] objectModel3D, HHomMat3D homMat3D)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(1097);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, homMat3D);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(homMat3D);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Apply an arbitrary projective 3D transformation to 3D object models.
		///   Instance represents: Handles of the 3D object models.
		/// </summary>
		/// <param name="homMat3D">Homogeneous projective transformation matrix.</param>
		/// <returns>Handles of the transformed 3D object models.</returns>
		// Token: 0x06000B8E RID: 2958 RVA: 0x00049324 File Offset: 0x00047524
		public HObjectModel3D ProjectiveTransObjectModel3d(HHomMat3D homMat3D)
		{
			IntPtr proc = HalconAPI.PreCall(1097);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, homMat3D);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat3D);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Apply an arbitrary affine 3D transformation to 3D object models.</summary>
		/// <param name="objectModel3D">Handles of the 3D object models.</param>
		/// <param name="homMat3D">Transformation matrices.</param>
		/// <returns>Handles of the transformed 3D object models.</returns>
		// Token: 0x06000B8F RID: 2959 RVA: 0x00049384 File Offset: 0x00047584
		public static HObjectModel3D[] AffineTransObjectModel3d(HObjectModel3D[] objectModel3D, HHomMat3D[] homMat3D)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			HTuple htuple2 = HData.ConcatArray(homMat3D);
			IntPtr proc = HalconAPI.PreCall(1098);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, htuple2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(htuple2);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Apply an arbitrary affine 3D transformation to 3D object models.
		///   Instance represents: Handles of the 3D object models.
		/// </summary>
		/// <param name="homMat3D">Transformation matrices.</param>
		/// <returns>Handles of the transformed 3D object models.</returns>
		// Token: 0x06000B90 RID: 2960 RVA: 0x000493F4 File Offset: 0x000475F4
		public HObjectModel3D AffineTransObjectModel3d(HHomMat3D homMat3D)
		{
			IntPtr proc = HalconAPI.PreCall(1098);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, homMat3D);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat3D);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Free the memory of a 3D object model.</summary>
		/// <param name="objectModel3D">Handle of the 3D object model.</param>
		// Token: 0x06000B91 RID: 2961 RVA: 0x00049454 File Offset: 0x00047654
		public static void ClearObjectModel3d(HObjectModel3D[] objectModel3D)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(1100);
			HalconAPI.Store(proc, 0, htuple);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(objectModel3D);
		}

		/// <summary>
		///   Free the memory of a 3D object model.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		// Token: 0x06000B92 RID: 2962 RVA: 0x00049498 File Offset: 0x00047698
		public void ClearObjectModel3d()
		{
			IntPtr proc = HalconAPI.PreCall(1100);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Serialize a 3D object model.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <returns>Handle of the serialized item.</returns>
		// Token: 0x06000B93 RID: 2963 RVA: 0x000494CC File Offset: 0x000476CC
		public HSerializedItem SerializeObjectModel3d()
		{
			IntPtr proc = HalconAPI.PreCall(1101);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HSerializedItem result;
			num = HSerializedItem.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Deserialize a serialized 3D object model.
		///   Modified instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="serializedItemHandle">Handle of the serialized item.</param>
		// Token: 0x06000B94 RID: 2964 RVA: 0x00049514 File Offset: 0x00047714
		public void DeserializeObjectModel3d(HSerializedItem serializedItemHandle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1102);
			HalconAPI.Store(proc, 0, serializedItemHandle);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(serializedItemHandle);
		}

		/// <summary>
		///   Writes a 3D object model to a file.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="fileType">Type of the file that is written. Default: "om3"</param>
		/// <param name="fileName">Name of the file that is written.</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		// Token: 0x06000B95 RID: 2965 RVA: 0x00049568 File Offset: 0x00047768
		public void WriteObjectModel3d(string fileType, string fileName, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1103);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, fileType);
			HalconAPI.StoreS(proc, 2, fileName);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Writes a 3D object model to a file.
		///   Instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="fileType">Type of the file that is written. Default: "om3"</param>
		/// <param name="fileName">Name of the file that is written.</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		// Token: 0x06000B96 RID: 2966 RVA: 0x000495CC File Offset: 0x000477CC
		public void WriteObjectModel3d(string fileType, string fileName, string genParamName, string genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1103);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, fileType);
			HalconAPI.StoreS(proc, 2, fileName);
			HalconAPI.StoreS(proc, 3, genParamName);
			HalconAPI.StoreS(proc, 4, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Read a 3D object model from a file.
		///   Modified instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="fileName">Filename of the file to be read. Default: "mvtec_bunny_normals"</param>
		/// <param name="scale">Scale of the data in the file. Default: "m"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Status information.</returns>
		// Token: 0x06000B97 RID: 2967 RVA: 0x00049624 File Offset: 0x00047824
		public HTuple ReadObjectModel3d(string fileName, HTuple scale, HTuple genParamName, HTuple genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1104);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.Store(proc, 1, scale);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(scale);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Read a 3D object model from a file.
		///   Modified instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="fileName">Filename of the file to be read. Default: "mvtec_bunny_normals"</param>
		/// <param name="scale">Scale of the data in the file. Default: "m"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Status information.</returns>
		// Token: 0x06000B98 RID: 2968 RVA: 0x000496B0 File Offset: 0x000478B0
		public string ReadObjectModel3d(string fileName, string scale, string genParamName, string genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1104);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.StoreS(proc, 1, scale);
			HalconAPI.StoreS(proc, 2, genParamName);
			HalconAPI.StoreS(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			string result;
			num = HalconAPI.LoadS(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Compute the calibrated scene flow between two stereo image pairs.</summary>
		/// <param name="imageRect1T1">Input image 1 at time @f$t_{1}$t_1.</param>
		/// <param name="imageRect2T1">Input image 2 at time @f$t_{1}$t_1.</param>
		/// <param name="imageRect1T2">Input image 1 at time @f$t_{2}$t_2.</param>
		/// <param name="imageRect2T2">Input image 2 at time @f$t_{2}$t_2.</param>
		/// <param name="disparity">Disparity between input images 1 and 2 at time @f$t_{1}$t_1.</param>
		/// <param name="smoothingFlow">Weight of the regularization term relative to the data term (derivatives of the optical flow). Default: 40.0</param>
		/// <param name="smoothingDisparity">Weight of the regularization term relative to the data term (derivatives of the disparity change). Default: 40.0</param>
		/// <param name="genParamName">Parameter name(s) for the algorithm. Default: "default_parameters"</param>
		/// <param name="genParamValue">Parameter value(s) for the algorithm. Default: "accurate"</param>
		/// <param name="camParamRect1">Internal camera parameters of the rectified camera 1.</param>
		/// <param name="camParamRect2">Internal camera parameters of the rectified camera 2.</param>
		/// <param name="relPoseRect">Pose of the rectified camera 2 in relation to the rectified camera 1.</param>
		/// <returns>Handle of the 3D object model.</returns>
		// Token: 0x06000B99 RID: 2969 RVA: 0x0004972C File Offset: 0x0004792C
		public static HObjectModel3D[] SceneFlowCalib(HImage imageRect1T1, HImage imageRect2T1, HImage imageRect1T2, HImage imageRect2T2, HImage disparity, HTuple smoothingFlow, HTuple smoothingDisparity, HTuple genParamName, HTuple genParamValue, HCamPar camParamRect1, HCamPar camParamRect2, HPose relPoseRect)
		{
			IntPtr proc = HalconAPI.PreCall(1481);
			HalconAPI.Store(proc, 1, imageRect1T1);
			HalconAPI.Store(proc, 2, imageRect2T1);
			HalconAPI.Store(proc, 3, imageRect1T2);
			HalconAPI.Store(proc, 4, imageRect2T2);
			HalconAPI.Store(proc, 5, disparity);
			HalconAPI.Store(proc, 0, smoothingFlow);
			HalconAPI.Store(proc, 1, smoothingDisparity);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.Store(proc, 4, camParamRect1);
			HalconAPI.Store(proc, 5, camParamRect2);
			HalconAPI.Store(proc, 6, relPoseRect);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(smoothingFlow);
			HalconAPI.UnpinTuple(smoothingDisparity);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.UnpinTuple(camParamRect1);
			HalconAPI.UnpinTuple(camParamRect2);
			HalconAPI.UnpinTuple(relPoseRect);
			HObjectModel3D[] result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(imageRect1T1);
			GC.KeepAlive(imageRect2T1);
			GC.KeepAlive(imageRect1T2);
			GC.KeepAlive(imageRect2T2);
			GC.KeepAlive(disparity);
			return result;
		}

		/// <summary>
		///   Compute the calibrated scene flow between two stereo image pairs.
		///   Modified instance represents: Handle of the 3D object model.
		/// </summary>
		/// <param name="imageRect1T1">Input image 1 at time @f$t_{1}$t_1.</param>
		/// <param name="imageRect2T1">Input image 2 at time @f$t_{1}$t_1.</param>
		/// <param name="imageRect1T2">Input image 1 at time @f$t_{2}$t_2.</param>
		/// <param name="imageRect2T2">Input image 2 at time @f$t_{2}$t_2.</param>
		/// <param name="disparity">Disparity between input images 1 and 2 at time @f$t_{1}$t_1.</param>
		/// <param name="smoothingFlow">Weight of the regularization term relative to the data term (derivatives of the optical flow). Default: 40.0</param>
		/// <param name="smoothingDisparity">Weight of the regularization term relative to the data term (derivatives of the disparity change). Default: 40.0</param>
		/// <param name="genParamName">Parameter name(s) for the algorithm. Default: "default_parameters"</param>
		/// <param name="genParamValue">Parameter value(s) for the algorithm. Default: "accurate"</param>
		/// <param name="camParamRect1">Internal camera parameters of the rectified camera 1.</param>
		/// <param name="camParamRect2">Internal camera parameters of the rectified camera 2.</param>
		/// <param name="relPoseRect">Pose of the rectified camera 2 in relation to the rectified camera 1.</param>
		// Token: 0x06000B9A RID: 2970 RVA: 0x0004983C File Offset: 0x00047A3C
		public void SceneFlowCalib(HImage imageRect1T1, HImage imageRect2T1, HImage imageRect1T2, HImage imageRect2T2, HImage disparity, double smoothingFlow, double smoothingDisparity, string genParamName, string genParamValue, HCamPar camParamRect1, HCamPar camParamRect2, HPose relPoseRect)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1481);
			HalconAPI.Store(proc, 1, imageRect1T1);
			HalconAPI.Store(proc, 2, imageRect2T1);
			HalconAPI.Store(proc, 3, imageRect1T2);
			HalconAPI.Store(proc, 4, imageRect2T2);
			HalconAPI.Store(proc, 5, disparity);
			HalconAPI.StoreD(proc, 0, smoothingFlow);
			HalconAPI.StoreD(proc, 1, smoothingDisparity);
			HalconAPI.StoreS(proc, 2, genParamName);
			HalconAPI.StoreS(proc, 3, genParamValue);
			HalconAPI.Store(proc, 4, camParamRect1);
			HalconAPI.Store(proc, 5, camParamRect2);
			HalconAPI.Store(proc, 6, relPoseRect);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParamRect1);
			HalconAPI.UnpinTuple(camParamRect2);
			HalconAPI.UnpinTuple(relPoseRect);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageRect1T1);
			GC.KeepAlive(imageRect2T1);
			GC.KeepAlive(imageRect1T2);
			GC.KeepAlive(imageRect2T2);
			GC.KeepAlive(disparity);
		}

		/// <summary>
		///   Find edges in a 3D object model.
		///   Instance represents: Handle of the 3D object model whose edges should be computed.
		/// </summary>
		/// <param name="minAmplitude">Edge threshold.</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>3D object model containing the edges.</returns>
		// Token: 0x06000B9B RID: 2971 RVA: 0x0004993C File Offset: 0x00047B3C
		public HObjectModel3D EdgesObjectModel3d(HTuple minAmplitude, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(2067);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, minAmplitude);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(minAmplitude);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Find edges in a 3D object model.
		///   Instance represents: Handle of the 3D object model whose edges should be computed.
		/// </summary>
		/// <param name="minAmplitude">Edge threshold.</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>3D object model containing the edges.</returns>
		// Token: 0x06000B9C RID: 2972 RVA: 0x000499B0 File Offset: 0x00047BB0
		public HObjectModel3D EdgesObjectModel3d(double minAmplitude, string genParamName, double genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(2067);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, minAmplitude);
			HalconAPI.StoreS(proc, 2, genParamName);
			HalconAPI.StoreD(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Find the best matches of a surface model in a 3D scene and images.
		///   Instance represents: Handle of the 3D object model containing the scene.
		/// </summary>
		/// <param name="image">Images of the scene.</param>
		/// <param name="surfaceModelID">Handle of the surface model.</param>
		/// <param name="relSamplingDistance">Scene sampling distance relative to the diameter of the surface model. Default: 0.05</param>
		/// <param name="keyPointFraction">Fraction of sampled scene points used as key points. Default: 0.2</param>
		/// <param name="minScore">Minimum score of the returned poses. Default: 0</param>
		/// <param name="returnResultHandle">Enable returning a result handle in SurfaceMatchingResultID. Default: "false"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <param name="score">Score of the found instances of the surface model.</param>
		/// <param name="surfaceMatchingResultID">Handle of the matching result, if enabled in ReturnResultHandle.</param>
		/// <returns>3D pose of the surface model in the scene.</returns>
		// Token: 0x06000B9D RID: 2973 RVA: 0x00049A10 File Offset: 0x00047C10
		public HPose[] FindSurfaceModelImage(HImage image, HSurfaceModel surfaceModelID, double relSamplingDistance, double keyPointFraction, HTuple minScore, string returnResultHandle, HTuple genParamName, HTuple genParamValue, out HTuple score, out HSurfaceMatchingResult[] surfaceMatchingResultID)
		{
			IntPtr proc = HalconAPI.PreCall(2069);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.Store(proc, 0, surfaceModelID);
			HalconAPI.StoreD(proc, 2, relSamplingDistance);
			HalconAPI.StoreD(proc, 3, keyPointFraction);
			HalconAPI.Store(proc, 4, minScore);
			HalconAPI.StoreS(proc, 5, returnResultHandle);
			HalconAPI.Store(proc, 6, genParamName);
			HalconAPI.Store(proc, 7, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out score);
			num = HSurfaceMatchingResult.LoadNew(proc, 2, num, out surfaceMatchingResultID);
			HalconAPI.PostCall(proc, num);
			HPose[] result = HPose.SplitArray(data);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(surfaceModelID);
			return result;
		}

		/// <summary>
		///   Find the best matches of a surface model in a 3D scene and images.
		///   Instance represents: Handle of the 3D object model containing the scene.
		/// </summary>
		/// <param name="image">Images of the scene.</param>
		/// <param name="surfaceModelID">Handle of the surface model.</param>
		/// <param name="relSamplingDistance">Scene sampling distance relative to the diameter of the surface model. Default: 0.05</param>
		/// <param name="keyPointFraction">Fraction of sampled scene points used as key points. Default: 0.2</param>
		/// <param name="minScore">Minimum score of the returned poses. Default: 0</param>
		/// <param name="returnResultHandle">Enable returning a result handle in SurfaceMatchingResultID. Default: "false"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <param name="score">Score of the found instances of the surface model.</param>
		/// <param name="surfaceMatchingResultID">Handle of the matching result, if enabled in ReturnResultHandle.</param>
		/// <returns>3D pose of the surface model in the scene.</returns>
		// Token: 0x06000B9E RID: 2974 RVA: 0x00049AEC File Offset: 0x00047CEC
		public HPose FindSurfaceModelImage(HImage image, HSurfaceModel surfaceModelID, double relSamplingDistance, double keyPointFraction, double minScore, string returnResultHandle, HTuple genParamName, HTuple genParamValue, out HTuple score, out HSurfaceMatchingResult surfaceMatchingResultID)
		{
			IntPtr proc = HalconAPI.PreCall(2069);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.Store(proc, 0, surfaceModelID);
			HalconAPI.StoreD(proc, 2, relSamplingDistance);
			HalconAPI.StoreD(proc, 3, keyPointFraction);
			HalconAPI.StoreD(proc, 4, minScore);
			HalconAPI.StoreS(proc, 5, returnResultHandle);
			HalconAPI.Store(proc, 6, genParamName);
			HalconAPI.Store(proc, 7, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out score);
			num = HSurfaceMatchingResult.LoadNew(proc, 2, num, out surfaceMatchingResultID);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(surfaceModelID);
			return result;
		}

		/// <summary>
		///   Refine the pose of a surface model in a 3D scene and in images.
		///   Instance represents: Handle of the 3D object model containing the scene.
		/// </summary>
		/// <param name="image">Images of the scene.</param>
		/// <param name="surfaceModelID">Handle of the surface model.</param>
		/// <param name="initialPose">Initial pose of the surface model in the scene.</param>
		/// <param name="minScore">Minimum score of the returned poses. Default: 0</param>
		/// <param name="returnResultHandle">Enable returning a result handle in SurfaceMatchingResultID. Default: "false"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <param name="score">Score of the found instances of the model.</param>
		/// <param name="surfaceMatchingResultID">Handle of the matching result, if enabled in ReturnResultHandle.</param>
		/// <returns>3D pose of the surface model in the scene.</returns>
		// Token: 0x06000B9F RID: 2975 RVA: 0x00049BBC File Offset: 0x00047DBC
		public HPose[] RefineSurfaceModelPoseImage(HImage image, HSurfaceModel surfaceModelID, HPose[] initialPose, HTuple minScore, string returnResultHandle, HTuple genParamName, HTuple genParamValue, out HTuple score, out HSurfaceMatchingResult[] surfaceMatchingResultID)
		{
			HTuple htuple = HData.ConcatArray(initialPose);
			IntPtr proc = HalconAPI.PreCall(2084);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.Store(proc, 0, surfaceModelID);
			HalconAPI.Store(proc, 2, htuple);
			HalconAPI.Store(proc, 3, minScore);
			HalconAPI.StoreS(proc, 4, returnResultHandle);
			HalconAPI.Store(proc, 5, genParamName);
			HalconAPI.Store(proc, 6, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out score);
			num = HSurfaceMatchingResult.LoadNew(proc, 2, num, out surfaceMatchingResultID);
			HalconAPI.PostCall(proc, num);
			HPose[] result = HPose.SplitArray(data);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(surfaceModelID);
			return result;
		}

		/// <summary>
		///   Refine the pose of a surface model in a 3D scene and in images.
		///   Instance represents: Handle of the 3D object model containing the scene.
		/// </summary>
		/// <param name="image">Images of the scene.</param>
		/// <param name="surfaceModelID">Handle of the surface model.</param>
		/// <param name="initialPose">Initial pose of the surface model in the scene.</param>
		/// <param name="minScore">Minimum score of the returned poses. Default: 0</param>
		/// <param name="returnResultHandle">Enable returning a result handle in SurfaceMatchingResultID. Default: "false"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <param name="score">Score of the found instances of the model.</param>
		/// <param name="surfaceMatchingResultID">Handle of the matching result, if enabled in ReturnResultHandle.</param>
		/// <returns>3D pose of the surface model in the scene.</returns>
		// Token: 0x06000BA0 RID: 2976 RVA: 0x00049CA0 File Offset: 0x00047EA0
		public HPose RefineSurfaceModelPoseImage(HImage image, HSurfaceModel surfaceModelID, HPose initialPose, double minScore, string returnResultHandle, HTuple genParamName, HTuple genParamValue, out HTuple score, out HSurfaceMatchingResult surfaceMatchingResultID)
		{
			IntPtr proc = HalconAPI.PreCall(2084);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.Store(proc, 0, surfaceModelID);
			HalconAPI.Store(proc, 2, initialPose);
			HalconAPI.StoreD(proc, 3, minScore);
			HalconAPI.StoreS(proc, 4, returnResultHandle);
			HalconAPI.Store(proc, 5, genParamName);
			HalconAPI.Store(proc, 6, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(initialPose);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out score);
			num = HSurfaceMatchingResult.LoadNew(proc, 2, num, out surfaceMatchingResultID);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(surfaceModelID);
			return result;
		}

		/// <summary>Fuse 3D object models into a surface.</summary>
		/// <param name="objectModel3D">Handles of the 3D object models.</param>
		/// <param name="boundingBox">The two opposite bound box corners.</param>
		/// <param name="resolution">Used resolution within the bounding box. Default: 1.0</param>
		/// <param name="surfaceTolerance">Distance of expected noise to surface. Default: 1.0</param>
		/// <param name="minThickness">Minimum thickness of the object in direction of the surface normal. Default: 1.0</param>
		/// <param name="smoothing">Weight factor for data fidelity. Default: 1.0</param>
		/// <param name="normalDirection">Direction of normals of the input models. Default: "inwards"</param>
		/// <param name="genParamName">Name of the generic parameter. Default: []</param>
		/// <param name="genParamValue">Value of the generic parameter. Default: []</param>
		/// <returns>Handle of the fused 3D object model.</returns>
		// Token: 0x06000BA1 RID: 2977 RVA: 0x00049D78 File Offset: 0x00047F78
		public static HObjectModel3D FuseObjectModel3d(HObjectModel3D[] objectModel3D, HTuple boundingBox, HTuple resolution, HTuple surfaceTolerance, HTuple minThickness, HTuple smoothing, HTuple normalDirection, HTuple genParamName, HTuple genParamValue)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			IntPtr proc = HalconAPI.PreCall(2112);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, boundingBox);
			HalconAPI.Store(proc, 2, resolution);
			HalconAPI.Store(proc, 3, surfaceTolerance);
			HalconAPI.Store(proc, 4, minThickness);
			HalconAPI.Store(proc, 5, smoothing);
			HalconAPI.Store(proc, 6, normalDirection);
			HalconAPI.Store(proc, 7, genParamName);
			HalconAPI.Store(proc, 8, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(boundingBox);
			HalconAPI.UnpinTuple(resolution);
			HalconAPI.UnpinTuple(surfaceTolerance);
			HalconAPI.UnpinTuple(minThickness);
			HalconAPI.UnpinTuple(smoothing);
			HalconAPI.UnpinTuple(normalDirection);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Fuse 3D object models into a surface.
		///   Instance represents: Handles of the 3D object models.
		/// </summary>
		/// <param name="boundingBox">The two opposite bound box corners.</param>
		/// <param name="resolution">Used resolution within the bounding box. Default: 1.0</param>
		/// <param name="surfaceTolerance">Distance of expected noise to surface. Default: 1.0</param>
		/// <param name="minThickness">Minimum thickness of the object in direction of the surface normal. Default: 1.0</param>
		/// <param name="smoothing">Weight factor for data fidelity. Default: 1.0</param>
		/// <param name="normalDirection">Direction of normals of the input models. Default: "inwards"</param>
		/// <param name="genParamName">Name of the generic parameter. Default: []</param>
		/// <param name="genParamValue">Value of the generic parameter. Default: []</param>
		/// <returns>Handle of the fused 3D object model.</returns>
		// Token: 0x06000BA2 RID: 2978 RVA: 0x00049E48 File Offset: 0x00048048
		public HObjectModel3D FuseObjectModel3d(HTuple boundingBox, double resolution, double surfaceTolerance, double minThickness, double smoothing, string normalDirection, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(2112);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, boundingBox);
			HalconAPI.StoreD(proc, 2, resolution);
			HalconAPI.StoreD(proc, 3, surfaceTolerance);
			HalconAPI.StoreD(proc, 4, minThickness);
			HalconAPI.StoreD(proc, 5, smoothing);
			HalconAPI.StoreS(proc, 6, normalDirection);
			HalconAPI.Store(proc, 7, genParamName);
			HalconAPI.Store(proc, 8, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(boundingBox);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Find boxes in 3D data.
		///   Instance represents: Handle of 3D object model where to search the box.
		/// </summary>
		/// <param name="sideLen1">Length of the first box side.</param>
		/// <param name="sideLen2">Length of the second box side.</param>
		/// <param name="sideLen3">Length of the third box side. Default: -1</param>
		/// <param name="minScore">Minimum score of the returned boxes. Default: 0.6</param>
		/// <param name="genParam">Dictionary for generic parameters. Default: []</param>
		/// <param name="score">Scores of the detected boxes.</param>
		/// <param name="objectModel3DBox">Detected boxes as triangulated 3D object models.</param>
		/// <param name="boxInformation">Additional debug information as dictionary.</param>
		/// <returns>Gripping poses of the detected boxes.</returns>
		// Token: 0x06000BA3 RID: 2979 RVA: 0x00049EEC File Offset: 0x000480EC
		public HPose[] FindBox3d(HTuple sideLen1, HTuple sideLen2, HTuple sideLen3, HTuple minScore, HDict genParam, out HTuple score, out HObjectModel3D[] objectModel3DBox, out HDict boxInformation)
		{
			IntPtr proc = HalconAPI.PreCall(2181);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, sideLen1);
			HalconAPI.Store(proc, 2, sideLen2);
			HalconAPI.Store(proc, 3, sideLen3);
			HalconAPI.Store(proc, 4, minScore);
			HalconAPI.Store(proc, 5, genParam);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(sideLen1);
			HalconAPI.UnpinTuple(sideLen2);
			HalconAPI.UnpinTuple(sideLen3);
			HalconAPI.UnpinTuple(minScore);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out score);
			num = HObjectModel3D.LoadNew(proc, 2, num, out objectModel3DBox);
			num = HDict.LoadNew(proc, 3, num, out boxInformation);
			HalconAPI.PostCall(proc, num);
			HPose[] result = HPose.SplitArray(data);
			GC.KeepAlive(this);
			GC.KeepAlive(genParam);
			return result;
		}

		/// <summary>
		///   Find boxes in 3D data.
		///   Instance represents: Handle of 3D object model where to search the box.
		/// </summary>
		/// <param name="sideLen1">Length of the first box side.</param>
		/// <param name="sideLen2">Length of the second box side.</param>
		/// <param name="sideLen3">Length of the third box side. Default: -1</param>
		/// <param name="minScore">Minimum score of the returned boxes. Default: 0.6</param>
		/// <param name="genParam">Dictionary for generic parameters. Default: []</param>
		/// <param name="score">Scores of the detected boxes.</param>
		/// <param name="objectModel3DBox">Detected boxes as triangulated 3D object models.</param>
		/// <param name="boxInformation">Additional debug information as dictionary.</param>
		/// <returns>Gripping poses of the detected boxes.</returns>
		// Token: 0x06000BA4 RID: 2980 RVA: 0x00049FC0 File Offset: 0x000481C0
		public HPose FindBox3d(HTuple sideLen1, HTuple sideLen2, HTuple sideLen3, double minScore, HDict genParam, out HTuple score, out HObjectModel3D[] objectModel3DBox, out HDict boxInformation)
		{
			IntPtr proc = HalconAPI.PreCall(2181);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, sideLen1);
			HalconAPI.Store(proc, 2, sideLen2);
			HalconAPI.Store(proc, 3, sideLen3);
			HalconAPI.StoreD(proc, 4, minScore);
			HalconAPI.Store(proc, 5, genParam);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(sideLen1);
			HalconAPI.UnpinTuple(sideLen2);
			HalconAPI.UnpinTuple(sideLen3);
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out score);
			num = HObjectModel3D.LoadNew(proc, 2, num, out objectModel3DBox);
			num = HDict.LoadNew(proc, 3, num, out boxInformation);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(genParam);
			return result;
		}

		/// <summary>
		///   Remove attributes of a 3D object model.
		///   Instance represents: Handle of the input 3D object model.
		/// </summary>
		/// <param name="attributes">Name of the attributes to be removed. Default: "extended_attribute"</param>
		/// <returns>Handle of the resulting 3D object model.</returns>
		// Token: 0x06000BA5 RID: 2981 RVA: 0x0004A088 File Offset: 0x00048288
		public HObjectModel3D RemoveObjectModel3dAttrib(HTuple attributes)
		{
			IntPtr proc = HalconAPI.PreCall(2187);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, attributes);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(attributes);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Remove attributes of a 3D object model.
		///   Instance represents: Handle of the input 3D object model.
		/// </summary>
		/// <param name="attributes">Name of the attributes to be removed. Default: "extended_attribute"</param>
		/// <returns>Handle of the resulting 3D object model.</returns>
		// Token: 0x06000BA6 RID: 2982 RVA: 0x0004A0E0 File Offset: 0x000482E0
		public HObjectModel3D RemoveObjectModel3dAttrib(string attributes)
		{
			IntPtr proc = HalconAPI.PreCall(2187);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, attributes);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Remove attributes of a 3D object model.
		///   Instance represents: Handle of the input 3D object model.
		/// </summary>
		/// <param name="attributes">Name of the attributes to be removed. Default: "extended_attribute"</param>
		// Token: 0x06000BA7 RID: 2983 RVA: 0x0004A130 File Offset: 0x00048330
		public void RemoveObjectModel3dAttribMod(HTuple attributes)
		{
			IntPtr proc = HalconAPI.PreCall(2188);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, attributes);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(attributes);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Remove attributes of a 3D object model.
		///   Instance represents: Handle of the input 3D object model.
		/// </summary>
		/// <param name="attributes">Name of the attributes to be removed. Default: "extended_attribute"</param>
		// Token: 0x06000BA8 RID: 2984 RVA: 0x0004A174 File Offset: 0x00048374
		public void RemoveObjectModel3dAttribMod(string attributes)
		{
			IntPtr proc = HalconAPI.PreCall(2188);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, attributes);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}
	}
}
